1use super::cbor_encodings::*;
5use super::*;
6use cbor_event::de::Deserializer;
7use cbor_event::se::Serializer;
8use cml_core::error::*;
9use cml_core::serialization::*;
10
11use cml_crypto::RawBytesEncoding;
12use std::io::{BufRead, Seek, SeekFrom, Write};
13
14impl Serialize for AuthCommitteeHotCert {
15 fn serialize<'se, W: Write>(
16 &self,
17 serializer: &'se mut Serializer<W>,
18 force_canonical: bool,
19 ) -> cbor_event::Result<&'se mut Serializer<W>> {
20 serializer.write_array_sz(
21 self.encodings
22 .as_ref()
23 .map(|encs| encs.len_encoding)
24 .unwrap_or_default()
25 .to_len_sz(3, force_canonical),
26 )?;
27 self.serialize_as_embedded_group(serializer, force_canonical)
28 }
29}
30
31impl SerializeEmbeddedGroup for AuthCommitteeHotCert {
32 fn serialize_as_embedded_group<'se, W: Write>(
33 &self,
34 serializer: &'se mut Serializer<W>,
35 force_canonical: bool,
36 ) -> cbor_event::Result<&'se mut Serializer<W>> {
37 serializer.write_unsigned_integer_sz(
38 14u64,
39 fit_sz(
40 14u64,
41 self.encodings
42 .as_ref()
43 .map(|encs| encs.index_0_encoding)
44 .unwrap_or_default(),
45 force_canonical,
46 ),
47 )?;
48 self.committee_cold_credential
49 .serialize(serializer, force_canonical)?;
50 self.committee_hot_credential
51 .serialize(serializer, force_canonical)?;
52 self.encodings
53 .as_ref()
54 .map(|encs| encs.len_encoding)
55 .unwrap_or_default()
56 .end(serializer, force_canonical)
57 }
58}
59
60impl Deserialize for AuthCommitteeHotCert {
61 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
62 let len = raw.array_sz()?;
63 let mut read_len = CBORReadLen::new(len);
64 read_len.read_elems(3)?;
65 read_len.finish()?;
66 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
67 match len {
68 cbor_event::LenSz::Len(_, _) => (),
69 cbor_event::LenSz::Indefinite => match raw.special()? {
70 cbor_event::Special::Break => (),
71 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
72 },
73 }
74 ret
75 }
76}
77
78impl DeserializeEmbeddedGroup for AuthCommitteeHotCert {
79 fn deserialize_as_embedded_group<R: BufRead + Seek>(
80 raw: &mut Deserializer<R>,
81 _read_len: &mut CBORReadLen,
82 len: cbor_event::LenSz,
83 ) -> Result<Self, DeserializeError> {
84 let len_encoding = len.into();
85 (|| -> Result<_, DeserializeError> {
86 let index_0_encoding = (|| -> Result<_, DeserializeError> {
87 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
88 if index_0_value != 14 {
89 return Err(DeserializeFailure::FixedValueMismatch {
90 found: Key::Uint(index_0_value),
91 expected: Key::Uint(14),
92 }
93 .into());
94 }
95 Ok(Some(index_0_encoding))
96 })()
97 .map_err(|e| e.annotate("index_0"))?;
98 let committee_cold_credential = Credential::deserialize(raw)
99 .map_err(|e: DeserializeError| e.annotate("committee_cold_credential"))?;
100 let committee_hot_credential = Credential::deserialize(raw)
101 .map_err(|e: DeserializeError| e.annotate("committee_hot_credential"))?;
102 Ok(AuthCommitteeHotCert {
103 committee_cold_credential,
104 committee_hot_credential,
105 encodings: Some(AuthCommitteeHotCertEncoding {
106 len_encoding,
107 index_0_encoding,
108 }),
109 })
110 })()
111 .map_err(|e| e.annotate("AuthCommitteeHotCert"))
112 }
113}
114
115impl Serialize for Certificate {
116 fn serialize<'se, W: Write>(
117 &self,
118 serializer: &'se mut Serializer<W>,
119 force_canonical: bool,
120 ) -> cbor_event::Result<&'se mut Serializer<W>> {
121 match self {
122 Certificate::StakeRegistration(stake_registration) => {
123 stake_registration.serialize(serializer, force_canonical)
124 }
125 Certificate::StakeDeregistration(stake_deregistration) => {
126 stake_deregistration.serialize(serializer, force_canonical)
127 }
128 Certificate::StakeDelegation(stake_delegation) => {
129 stake_delegation.serialize(serializer, force_canonical)
130 }
131 Certificate::PoolRegistration(pool_registration) => {
132 pool_registration.serialize(serializer, force_canonical)
133 }
134 Certificate::PoolRetirement(pool_retirement) => {
135 pool_retirement.serialize(serializer, force_canonical)
136 }
137 Certificate::RegCert(reg_cert) => reg_cert.serialize(serializer, force_canonical),
138 Certificate::UnregCert(unreg_cert) => unreg_cert.serialize(serializer, force_canonical),
139 Certificate::VoteDelegCert(vote_deleg_cert) => {
140 vote_deleg_cert.serialize(serializer, force_canonical)
141 }
142 Certificate::StakeVoteDelegCert(stake_vote_deleg_cert) => {
143 stake_vote_deleg_cert.serialize(serializer, force_canonical)
144 }
145 Certificate::StakeRegDelegCert(stake_reg_deleg_cert) => {
146 stake_reg_deleg_cert.serialize(serializer, force_canonical)
147 }
148 Certificate::VoteRegDelegCert(vote_reg_deleg_cert) => {
149 vote_reg_deleg_cert.serialize(serializer, force_canonical)
150 }
151 Certificate::StakeVoteRegDelegCert(stake_vote_reg_deleg_cert) => {
152 stake_vote_reg_deleg_cert.serialize(serializer, force_canonical)
153 }
154 Certificate::AuthCommitteeHotCert(auth_committee_hot_cert) => {
155 auth_committee_hot_cert.serialize(serializer, force_canonical)
156 }
157 Certificate::ResignCommitteeColdCert(resign_committee_cold_cert) => {
158 resign_committee_cold_cert.serialize(serializer, force_canonical)
159 }
160 Certificate::RegDrepCert(reg_drep_cert) => {
161 reg_drep_cert.serialize(serializer, force_canonical)
162 }
163 Certificate::UnregDrepCert(unreg_drep_cert) => {
164 unreg_drep_cert.serialize(serializer, force_canonical)
165 }
166 Certificate::UpdateDrepCert(update_drep_cert) => {
167 update_drep_cert.serialize(serializer, force_canonical)
168 }
169 }
170 }
171}
172
173impl Deserialize for Certificate {
174 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
175 (|| -> Result<_, DeserializeError> {
176 let len = raw.array_sz()?;
177 let initial_position = raw.as_mut_ref().stream_position().unwrap();
178 let mut errs = Vec::new();
179 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
180 let mut read_len = CBORReadLen::new(len);
181 read_len.read_elems(2)?;
182 read_len.finish()?;
183 let ret = StakeRegistration::deserialize_as_embedded_group(raw, &mut read_len, len);
184 match len {
185 cbor_event::LenSz::Len(_, _) => (),
186 cbor_event::LenSz::Indefinite => match raw.special()? {
187 cbor_event::Special::Break => (),
188 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
189 },
190 }
191 ret
192 })(raw);
193 match deser_variant {
194 Ok(stake_registration) => return Ok(Self::StakeRegistration(stake_registration)),
195 Err(e) => {
196 errs.push(e.annotate("StakeRegistration"));
197 raw.as_mut_ref()
198 .seek(SeekFrom::Start(initial_position))
199 .unwrap();
200 }
201 };
202 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
203 let mut read_len = CBORReadLen::new(len);
204 read_len.read_elems(2)?;
205 read_len.finish()?;
206 let ret =
207 StakeDeregistration::deserialize_as_embedded_group(raw, &mut read_len, len);
208 match len {
209 cbor_event::LenSz::Len(_, _) => (),
210 cbor_event::LenSz::Indefinite => match raw.special()? {
211 cbor_event::Special::Break => (),
212 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
213 },
214 }
215 ret
216 })(raw);
217 match deser_variant {
218 Ok(stake_deregistration) => {
219 return Ok(Self::StakeDeregistration(stake_deregistration))
220 }
221 Err(e) => {
222 errs.push(e.annotate("StakeDeregistration"));
223 raw.as_mut_ref()
224 .seek(SeekFrom::Start(initial_position))
225 .unwrap();
226 }
227 };
228 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
229 let mut read_len = CBORReadLen::new(len);
230 read_len.read_elems(3)?;
231 read_len.finish()?;
232 let ret = StakeDelegation::deserialize_as_embedded_group(raw, &mut read_len, len);
233 match len {
234 cbor_event::LenSz::Len(_, _) => (),
235 cbor_event::LenSz::Indefinite => match raw.special()? {
236 cbor_event::Special::Break => (),
237 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
238 },
239 }
240 ret
241 })(raw);
242 match deser_variant {
243 Ok(stake_delegation) => return Ok(Self::StakeDelegation(stake_delegation)),
244 Err(e) => {
245 errs.push(e.annotate("StakeDelegation"));
246 raw.as_mut_ref()
247 .seek(SeekFrom::Start(initial_position))
248 .unwrap();
249 }
250 };
251 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
252 let mut read_len = CBORReadLen::new(len);
253 read_len.read_elems(10)?;
254 read_len.finish()?;
255 let ret = PoolRegistration::deserialize_as_embedded_group(raw, &mut read_len, len);
256 match len {
257 cbor_event::LenSz::Len(_, _) => (),
258 cbor_event::LenSz::Indefinite => match raw.special()? {
259 cbor_event::Special::Break => (),
260 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
261 },
262 }
263 ret
264 })(raw);
265 match deser_variant {
266 Ok(pool_registration) => return Ok(Self::PoolRegistration(pool_registration)),
267 Err(e) => {
268 errs.push(e.annotate("PoolRegistration"));
269 raw.as_mut_ref()
270 .seek(SeekFrom::Start(initial_position))
271 .unwrap();
272 }
273 };
274 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
275 let mut read_len = CBORReadLen::new(len);
276 read_len.read_elems(3)?;
277 read_len.finish()?;
278 let ret = PoolRetirement::deserialize_as_embedded_group(raw, &mut read_len, len);
279 match len {
280 cbor_event::LenSz::Len(_, _) => (),
281 cbor_event::LenSz::Indefinite => match raw.special()? {
282 cbor_event::Special::Break => (),
283 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
284 },
285 }
286 ret
287 })(raw);
288 match deser_variant {
289 Ok(pool_retirement) => return Ok(Self::PoolRetirement(pool_retirement)),
290 Err(e) => {
291 errs.push(e.annotate("PoolRetirement"));
292 raw.as_mut_ref()
293 .seek(SeekFrom::Start(initial_position))
294 .unwrap();
295 }
296 };
297 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
298 let mut read_len = CBORReadLen::new(len);
299 read_len.read_elems(3)?;
300 read_len.finish()?;
301 let ret = RegCert::deserialize_as_embedded_group(raw, &mut read_len, len);
302 match len {
303 cbor_event::LenSz::Len(_, _) => (),
304 cbor_event::LenSz::Indefinite => match raw.special()? {
305 cbor_event::Special::Break => (),
306 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
307 },
308 }
309 ret
310 })(raw);
311 match deser_variant {
312 Ok(reg_cert) => return Ok(Self::RegCert(reg_cert)),
313 Err(e) => {
314 errs.push(e.annotate("RegCert"));
315 raw.as_mut_ref()
316 .seek(SeekFrom::Start(initial_position))
317 .unwrap();
318 }
319 };
320 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
321 let mut read_len = CBORReadLen::new(len);
322 read_len.read_elems(3)?;
323 read_len.finish()?;
324 let ret = UnregCert::deserialize_as_embedded_group(raw, &mut read_len, len);
325 match len {
326 cbor_event::LenSz::Len(_, _) => (),
327 cbor_event::LenSz::Indefinite => match raw.special()? {
328 cbor_event::Special::Break => (),
329 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
330 },
331 }
332 ret
333 })(raw);
334 match deser_variant {
335 Ok(unreg_cert) => return Ok(Self::UnregCert(unreg_cert)),
336 Err(e) => {
337 errs.push(e.annotate("UnregCert"));
338 raw.as_mut_ref()
339 .seek(SeekFrom::Start(initial_position))
340 .unwrap();
341 }
342 };
343 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
344 let mut read_len = CBORReadLen::new(len);
345 read_len.read_elems(3)?;
346 read_len.finish()?;
347 let ret = VoteDelegCert::deserialize_as_embedded_group(raw, &mut read_len, len);
348 match len {
349 cbor_event::LenSz::Len(_, _) => (),
350 cbor_event::LenSz::Indefinite => match raw.special()? {
351 cbor_event::Special::Break => (),
352 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
353 },
354 }
355 ret
356 })(raw);
357 match deser_variant {
358 Ok(vote_deleg_cert) => return Ok(Self::VoteDelegCert(vote_deleg_cert)),
359 Err(e) => {
360 errs.push(e.annotate("VoteDelegCert"));
361 raw.as_mut_ref()
362 .seek(SeekFrom::Start(initial_position))
363 .unwrap();
364 }
365 };
366 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
367 let mut read_len = CBORReadLen::new(len);
368 read_len.read_elems(4)?;
369 read_len.finish()?;
370 let ret =
371 StakeVoteDelegCert::deserialize_as_embedded_group(raw, &mut read_len, len);
372 match len {
373 cbor_event::LenSz::Len(_, _) => (),
374 cbor_event::LenSz::Indefinite => match raw.special()? {
375 cbor_event::Special::Break => (),
376 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
377 },
378 }
379 ret
380 })(raw);
381 match deser_variant {
382 Ok(stake_vote_deleg_cert) => {
383 return Ok(Self::StakeVoteDelegCert(stake_vote_deleg_cert))
384 }
385 Err(e) => {
386 errs.push(e.annotate("StakeVoteDelegCert"));
387 raw.as_mut_ref()
388 .seek(SeekFrom::Start(initial_position))
389 .unwrap();
390 }
391 };
392 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
393 let mut read_len = CBORReadLen::new(len);
394 read_len.read_elems(4)?;
395 read_len.finish()?;
396 let ret = StakeRegDelegCert::deserialize_as_embedded_group(raw, &mut read_len, len);
397 match len {
398 cbor_event::LenSz::Len(_, _) => (),
399 cbor_event::LenSz::Indefinite => match raw.special()? {
400 cbor_event::Special::Break => (),
401 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
402 },
403 }
404 ret
405 })(raw);
406 match deser_variant {
407 Ok(stake_reg_deleg_cert) => {
408 return Ok(Self::StakeRegDelegCert(stake_reg_deleg_cert))
409 }
410 Err(e) => {
411 errs.push(e.annotate("StakeRegDelegCert"));
412 raw.as_mut_ref()
413 .seek(SeekFrom::Start(initial_position))
414 .unwrap();
415 }
416 };
417 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
418 let mut read_len = CBORReadLen::new(len);
419 read_len.read_elems(4)?;
420 read_len.finish()?;
421 let ret = VoteRegDelegCert::deserialize_as_embedded_group(raw, &mut read_len, len);
422 match len {
423 cbor_event::LenSz::Len(_, _) => (),
424 cbor_event::LenSz::Indefinite => match raw.special()? {
425 cbor_event::Special::Break => (),
426 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
427 },
428 }
429 ret
430 })(raw);
431 match deser_variant {
432 Ok(vote_reg_deleg_cert) => return Ok(Self::VoteRegDelegCert(vote_reg_deleg_cert)),
433 Err(e) => {
434 errs.push(e.annotate("VoteRegDelegCert"));
435 raw.as_mut_ref()
436 .seek(SeekFrom::Start(initial_position))
437 .unwrap();
438 }
439 };
440 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
441 let mut read_len = CBORReadLen::new(len);
442 read_len.read_elems(5)?;
443 read_len.finish()?;
444 let ret =
445 StakeVoteRegDelegCert::deserialize_as_embedded_group(raw, &mut read_len, len);
446 match len {
447 cbor_event::LenSz::Len(_, _) => (),
448 cbor_event::LenSz::Indefinite => match raw.special()? {
449 cbor_event::Special::Break => (),
450 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
451 },
452 }
453 ret
454 })(raw);
455 match deser_variant {
456 Ok(stake_vote_reg_deleg_cert) => {
457 return Ok(Self::StakeVoteRegDelegCert(stake_vote_reg_deleg_cert))
458 }
459 Err(e) => {
460 errs.push(e.annotate("StakeVoteRegDelegCert"));
461 raw.as_mut_ref()
462 .seek(SeekFrom::Start(initial_position))
463 .unwrap();
464 }
465 };
466 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
467 let mut read_len = CBORReadLen::new(len);
468 read_len.read_elems(3)?;
469 read_len.finish()?;
470 let ret =
471 AuthCommitteeHotCert::deserialize_as_embedded_group(raw, &mut read_len, len);
472 match len {
473 cbor_event::LenSz::Len(_, _) => (),
474 cbor_event::LenSz::Indefinite => match raw.special()? {
475 cbor_event::Special::Break => (),
476 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
477 },
478 }
479 ret
480 })(raw);
481 match deser_variant {
482 Ok(auth_committee_hot_cert) => {
483 return Ok(Self::AuthCommitteeHotCert(auth_committee_hot_cert))
484 }
485 Err(e) => {
486 errs.push(e.annotate("AuthCommitteeHotCert"));
487 raw.as_mut_ref()
488 .seek(SeekFrom::Start(initial_position))
489 .unwrap();
490 }
491 };
492 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
493 let mut read_len = CBORReadLen::new(len);
494 read_len.read_elems(3)?;
495 read_len.finish()?;
496 let ret =
497 ResignCommitteeColdCert::deserialize_as_embedded_group(raw, &mut read_len, len);
498 match len {
499 cbor_event::LenSz::Len(_, _) => (),
500 cbor_event::LenSz::Indefinite => match raw.special()? {
501 cbor_event::Special::Break => (),
502 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
503 },
504 }
505 ret
506 })(raw);
507 match deser_variant {
508 Ok(resign_committee_cold_cert) => {
509 return Ok(Self::ResignCommitteeColdCert(resign_committee_cold_cert))
510 }
511 Err(e) => {
512 errs.push(e.annotate("ResignCommitteeColdCert"));
513 raw.as_mut_ref()
514 .seek(SeekFrom::Start(initial_position))
515 .unwrap();
516 }
517 };
518 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
519 let mut read_len = CBORReadLen::new(len);
520 read_len.read_elems(4)?;
521 read_len.finish()?;
522 let ret = RegDrepCert::deserialize_as_embedded_group(raw, &mut read_len, len);
523 match len {
524 cbor_event::LenSz::Len(_, _) => (),
525 cbor_event::LenSz::Indefinite => match raw.special()? {
526 cbor_event::Special::Break => (),
527 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
528 },
529 }
530 ret
531 })(raw);
532 match deser_variant {
533 Ok(reg_drep_cert) => return Ok(Self::RegDrepCert(reg_drep_cert)),
534 Err(e) => {
535 errs.push(e.annotate("RegDrepCert"));
536 raw.as_mut_ref()
537 .seek(SeekFrom::Start(initial_position))
538 .unwrap();
539 }
540 };
541 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
542 let mut read_len = CBORReadLen::new(len);
543 read_len.read_elems(3)?;
544 read_len.finish()?;
545 let ret = UnregDrepCert::deserialize_as_embedded_group(raw, &mut read_len, len);
546 match len {
547 cbor_event::LenSz::Len(_, _) => (),
548 cbor_event::LenSz::Indefinite => match raw.special()? {
549 cbor_event::Special::Break => (),
550 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
551 },
552 }
553 ret
554 })(raw);
555 match deser_variant {
556 Ok(unreg_drep_cert) => return Ok(Self::UnregDrepCert(unreg_drep_cert)),
557 Err(e) => {
558 errs.push(e.annotate("UnregDrepCert"));
559 raw.as_mut_ref()
560 .seek(SeekFrom::Start(initial_position))
561 .unwrap();
562 }
563 };
564 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
565 let mut read_len = CBORReadLen::new(len);
566 read_len.read_elems(3)?;
567 read_len.finish()?;
568 let ret = UpdateDrepCert::deserialize_as_embedded_group(raw, &mut read_len, len);
569 match len {
570 cbor_event::LenSz::Len(_, _) => (),
571 cbor_event::LenSz::Indefinite => match raw.special()? {
572 cbor_event::Special::Break => (),
573 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
574 },
575 }
576 ret
577 })(raw);
578 match deser_variant {
579 Ok(update_drep_cert) => return Ok(Self::UpdateDrepCert(update_drep_cert)),
580 Err(e) => {
581 errs.push(e.annotate("UpdateDrepCert"));
582 raw.as_mut_ref()
583 .seek(SeekFrom::Start(initial_position))
584 .unwrap();
585 }
586 };
587 Err(DeserializeError::new(
588 "Certificate",
589 DeserializeFailure::NoVariantMatchedWithCauses(errs),
590 ))
591 })()
592 .map_err(|e| e.annotate("Certificate"))
593 }
594}
595
596impl Serialize for Credential {
597 fn serialize<'se, W: Write>(
598 &self,
599 serializer: &'se mut Serializer<W>,
600 force_canonical: bool,
601 ) -> cbor_event::Result<&'se mut Serializer<W>> {
602 match self {
603 Credential::PubKey {
604 hash,
605 len_encoding,
606 tag_encoding,
607 hash_encoding,
608 } => {
609 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
610 serializer.write_unsigned_integer_sz(
611 0u64,
612 fit_sz(0u64, *tag_encoding, force_canonical),
613 )?;
614 serializer.write_bytes_sz(
615 hash.to_raw_bytes(),
616 hash_encoding.to_str_len_sz(hash.to_raw_bytes().len() as u64, force_canonical),
617 )?;
618 len_encoding.end(serializer, force_canonical)?;
619 Ok(serializer)
620 }
621 Credential::Script {
622 hash,
623 len_encoding,
624 tag_encoding,
625 hash_encoding,
626 } => {
627 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
628 serializer.write_unsigned_integer_sz(
629 1u64,
630 fit_sz(1u64, *tag_encoding, force_canonical),
631 )?;
632 serializer.write_bytes_sz(
633 hash.to_raw_bytes(),
634 hash_encoding.to_str_len_sz(hash.to_raw_bytes().len() as u64, force_canonical),
635 )?;
636 len_encoding.end(serializer, force_canonical)?;
637 Ok(serializer)
638 }
639 }
640 }
641}
642
643impl Deserialize for Credential {
644 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
645 (|| -> Result<_, DeserializeError> {
646 let len = raw.array_sz()?;
647 let len_encoding: LenEncoding = len.into();
648 let initial_position = raw.as_mut_ref().stream_position().unwrap();
649 let mut errs = Vec::new();
650 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
651 let mut read_len = CBORReadLen::new(len);
652 read_len.read_elems(2)?;
653 read_len.finish()?;
654 let tag_encoding = (|| -> Result<_, DeserializeError> {
655 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
656 if tag_value != 0 {
657 return Err(DeserializeFailure::FixedValueMismatch {
658 found: Key::Uint(tag_value),
659 expected: Key::Uint(0),
660 }
661 .into());
662 }
663 Ok(Some(tag_encoding))
664 })()
665 .map_err(|e| e.annotate("tag"))?;
666 let (hash, hash_encoding) = raw
667 .bytes_sz()
668 .map_err(Into::<DeserializeError>::into)
669 .and_then(|(bytes, enc)| {
670 Ed25519KeyHash::from_raw_bytes(&bytes)
671 .map(|bytes| (bytes, StringEncoding::from(enc)))
672 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
673 })
674 .map_err(|e: DeserializeError| e.annotate("hash"))?;
675 match len {
676 cbor_event::LenSz::Len(_, _) => (),
677 cbor_event::LenSz::Indefinite => match raw.special()? {
678 cbor_event::Special::Break => (),
679 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
680 },
681 }
682 Ok(Self::PubKey {
683 hash,
684 len_encoding,
685 tag_encoding,
686 hash_encoding,
687 })
688 })(raw);
689 match variant_deser {
690 Ok(variant) => return Ok(variant),
691 Err(e) => {
692 errs.push(e.annotate("PubKey"));
693 raw.as_mut_ref()
694 .seek(SeekFrom::Start(initial_position))
695 .unwrap();
696 }
697 };
698 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
699 let mut read_len = CBORReadLen::new(len);
700 read_len.read_elems(2)?;
701 read_len.finish()?;
702 let tag_encoding = (|| -> Result<_, DeserializeError> {
703 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
704 if tag_value != 1 {
705 return Err(DeserializeFailure::FixedValueMismatch {
706 found: Key::Uint(tag_value),
707 expected: Key::Uint(1),
708 }
709 .into());
710 }
711 Ok(Some(tag_encoding))
712 })()
713 .map_err(|e| e.annotate("tag"))?;
714 let (hash, hash_encoding) = raw
715 .bytes_sz()
716 .map_err(Into::<DeserializeError>::into)
717 .and_then(|(bytes, enc)| {
718 ScriptHash::from_raw_bytes(&bytes)
719 .map(|bytes| (bytes, StringEncoding::from(enc)))
720 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
721 })
722 .map_err(|e: DeserializeError| e.annotate("hash"))?;
723 match len {
724 cbor_event::LenSz::Len(_, _) => (),
725 cbor_event::LenSz::Indefinite => match raw.special()? {
726 cbor_event::Special::Break => (),
727 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
728 },
729 }
730 Ok(Self::Script {
731 hash,
732 len_encoding,
733 tag_encoding,
734 hash_encoding,
735 })
736 })(raw);
737 match variant_deser {
738 Ok(variant) => return Ok(variant),
739 Err(e) => {
740 errs.push(e.annotate("Script"));
741 raw.as_mut_ref()
742 .seek(SeekFrom::Start(initial_position))
743 .unwrap();
744 }
745 };
746 Err(DeserializeError::new(
747 "Credential",
748 DeserializeFailure::NoVariantMatchedWithCauses(errs),
749 ))
750 })()
751 .map_err(|e| e.annotate("Credential"))
752 }
753}
754
755impl Serialize for DNSName {
756 fn serialize<'se, W: Write>(
757 &self,
758 serializer: &'se mut Serializer<W>,
759 force_canonical: bool,
760 ) -> cbor_event::Result<&'se mut Serializer<W>> {
761 serializer.write_text_sz(
762 &self.inner,
763 self.encodings
764 .as_ref()
765 .map(|encs| encs.inner_encoding.clone())
766 .unwrap_or_default()
767 .to_str_len_sz(self.inner.len() as u64, force_canonical),
768 )
769 }
770}
771
772impl Deserialize for DNSName {
773 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
774 let (inner, inner_encoding) = raw
775 .text_sz()
776 .map(|(s, enc)| (s, StringEncoding::from(enc)))?;
777 if inner.len() > 128 {
778 return Err(DeserializeError::new(
779 "DNSName",
780 DeserializeFailure::RangeCheck {
781 found: inner.len() as isize,
782 min: Some(0),
783 max: Some(128),
784 },
785 ));
786 }
787 Ok(Self {
788 inner,
789 encodings: Some(DNSNameEncoding { inner_encoding }),
790 })
791 }
792}
793
794impl Serialize for DRep {
795 fn serialize<'se, W: Write>(
796 &self,
797 serializer: &'se mut Serializer<W>,
798 force_canonical: bool,
799 ) -> cbor_event::Result<&'se mut Serializer<W>> {
800 match self {
801 DRep::Key {
802 pool,
803 len_encoding,
804 index_0_encoding,
805 pool_encoding,
806 } => {
807 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
808 serializer.write_unsigned_integer_sz(
809 0u64,
810 fit_sz(0u64, *index_0_encoding, force_canonical),
811 )?;
812 serializer.write_bytes_sz(
813 pool.to_raw_bytes(),
814 pool_encoding.to_str_len_sz(pool.to_raw_bytes().len() as u64, force_canonical),
815 )?;
816 len_encoding.end(serializer, force_canonical)?;
817 Ok(serializer)
818 }
819 DRep::Script {
820 script_hash,
821 len_encoding,
822 index_0_encoding,
823 script_hash_encoding,
824 } => {
825 serializer.write_array_sz(len_encoding.to_len_sz(2, force_canonical))?;
826 serializer.write_unsigned_integer_sz(
827 1u64,
828 fit_sz(1u64, *index_0_encoding, force_canonical),
829 )?;
830 serializer.write_bytes_sz(
831 script_hash.to_raw_bytes(),
832 script_hash_encoding
833 .to_str_len_sz(script_hash.to_raw_bytes().len() as u64, force_canonical),
834 )?;
835 len_encoding.end(serializer, force_canonical)?;
836 Ok(serializer)
837 }
838 DRep::AlwaysAbstain {
839 always_abstain_encoding,
840 len_encoding,
841 } => {
842 serializer.write_array_sz(len_encoding.to_len_sz(1, force_canonical))?;
843 serializer.write_unsigned_integer_sz(
844 2u64,
845 fit_sz(2u64, *always_abstain_encoding, force_canonical),
846 )?;
847 len_encoding.end(serializer, force_canonical)?;
848 Ok(serializer)
849 }
850 DRep::AlwaysNoConfidence {
851 always_no_confidence_encoding,
852 len_encoding,
853 } => {
854 serializer.write_array_sz(len_encoding.to_len_sz(1, force_canonical))?;
855 serializer.write_unsigned_integer_sz(
856 3u64,
857 fit_sz(3u64, *always_no_confidence_encoding, force_canonical),
858 )?;
859 len_encoding.end(serializer, force_canonical)?;
860 Ok(serializer)
861 }
862 }
863 }
864}
865
866impl Deserialize for DRep {
867 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
868 (|| -> Result<_, DeserializeError> {
869 let len = raw.array_sz()?;
870 let len_encoding: LenEncoding = len.into();
871 let initial_position = raw.as_mut_ref().stream_position().unwrap();
872 let mut errs = Vec::new();
873 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
874 let mut read_len = CBORReadLen::new(len);
875 read_len.read_elems(2)?;
876 read_len.finish()?;
877 let index_0_encoding = (|| -> Result<_, DeserializeError> {
878 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
879 if index_0_value != 0 {
880 return Err(DeserializeFailure::FixedValueMismatch {
881 found: Key::Uint(index_0_value),
882 expected: Key::Uint(0),
883 }
884 .into());
885 }
886 Ok(Some(index_0_encoding))
887 })()
888 .map_err(|e| e.annotate("index_0"))?;
889 let (pool, pool_encoding) = raw
890 .bytes_sz()
891 .map_err(Into::<DeserializeError>::into)
892 .and_then(|(bytes, enc)| {
893 Ed25519KeyHash::from_raw_bytes(&bytes)
894 .map(|bytes| (bytes, StringEncoding::from(enc)))
895 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
896 })
897 .map_err(|e: DeserializeError| e.annotate("pool"))?;
898 match len {
899 cbor_event::LenSz::Len(_, _) => (),
900 cbor_event::LenSz::Indefinite => match raw.special()? {
901 cbor_event::Special::Break => (),
902 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
903 },
904 }
905 Ok(Self::Key {
906 pool,
907 len_encoding,
908 index_0_encoding,
909 pool_encoding,
910 })
911 })(raw);
912 match variant_deser {
913 Ok(variant) => return Ok(variant),
914 Err(e) => {
915 errs.push(e.annotate("Key"));
916 raw.as_mut_ref()
917 .seek(SeekFrom::Start(initial_position))
918 .unwrap();
919 }
920 };
921 let variant_deser = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
922 let mut read_len = CBORReadLen::new(len);
923 read_len.read_elems(2)?;
924 read_len.finish()?;
925 let index_0_encoding = (|| -> Result<_, DeserializeError> {
926 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
927 if index_0_value != 1 {
928 return Err(DeserializeFailure::FixedValueMismatch {
929 found: Key::Uint(index_0_value),
930 expected: Key::Uint(1),
931 }
932 .into());
933 }
934 Ok(Some(index_0_encoding))
935 })()
936 .map_err(|e| e.annotate("index_0"))?;
937 let (script_hash, script_hash_encoding) = raw
938 .bytes_sz()
939 .map_err(Into::<DeserializeError>::into)
940 .and_then(|(bytes, enc)| {
941 ScriptHash::from_raw_bytes(&bytes)
942 .map(|bytes| (bytes, StringEncoding::from(enc)))
943 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
944 })
945 .map_err(|e: DeserializeError| e.annotate("script_hash"))?;
946 match len {
947 cbor_event::LenSz::Len(_, _) => (),
948 cbor_event::LenSz::Indefinite => match raw.special()? {
949 cbor_event::Special::Break => (),
950 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
951 },
952 }
953 Ok(Self::Script {
954 script_hash,
955 len_encoding,
956 index_0_encoding,
957 script_hash_encoding,
958 })
959 })(raw);
960 match variant_deser {
961 Ok(variant) => return Ok(variant),
962 Err(e) => {
963 errs.push(e.annotate("Script"));
964 raw.as_mut_ref()
965 .seek(SeekFrom::Start(initial_position))
966 .unwrap();
967 }
968 };
969 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
970 let mut read_len = CBORReadLen::new(len);
971 read_len.read_elems(1)?;
972 read_len.finish()?;
973 let (always_abstain_value, always_abstain_encoding) = raw.unsigned_integer_sz()?;
974 if always_abstain_value != 2 {
975 return Err(DeserializeFailure::FixedValueMismatch {
976 found: Key::Uint(always_abstain_value),
977 expected: Key::Uint(2),
978 }
979 .into());
980 }
981 let ret = Ok(Some(always_abstain_encoding));
982 match len {
983 cbor_event::LenSz::Len(_, _) => (),
984 cbor_event::LenSz::Indefinite => match raw.special()? {
985 cbor_event::Special::Break => (),
986 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
987 },
988 }
989 ret
990 })(raw);
991 match deser_variant {
992 Ok(always_abstain_encoding) => {
993 return Ok(Self::AlwaysAbstain {
994 always_abstain_encoding,
995 len_encoding,
996 })
997 }
998 Err(e) => {
999 errs.push(e.annotate("AlwaysAbstain"));
1000 raw.as_mut_ref()
1001 .seek(SeekFrom::Start(initial_position))
1002 .unwrap();
1003 }
1004 };
1005 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1006 let mut read_len = CBORReadLen::new(len);
1007 read_len.read_elems(1)?;
1008 read_len.finish()?;
1009 let (always_no_confidence_value, always_no_confidence_encoding) =
1010 raw.unsigned_integer_sz()?;
1011 if always_no_confidence_value != 3 {
1012 return Err(DeserializeFailure::FixedValueMismatch {
1013 found: Key::Uint(always_no_confidence_value),
1014 expected: Key::Uint(3),
1015 }
1016 .into());
1017 }
1018 let ret = Ok(Some(always_no_confidence_encoding));
1019 match len {
1020 cbor_event::LenSz::Len(_, _) => (),
1021 cbor_event::LenSz::Indefinite => match raw.special()? {
1022 cbor_event::Special::Break => (),
1023 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1024 },
1025 }
1026 ret
1027 })(raw);
1028 match deser_variant {
1029 Ok(always_no_confidence_encoding) => {
1030 return Ok(Self::AlwaysNoConfidence {
1031 always_no_confidence_encoding,
1032 len_encoding,
1033 })
1034 }
1035 Err(e) => {
1036 errs.push(e.annotate("AlwaysNoConfidence"));
1037 raw.as_mut_ref()
1038 .seek(SeekFrom::Start(initial_position))
1039 .unwrap();
1040 }
1041 };
1042 Err(DeserializeError::new(
1043 "DRep",
1044 DeserializeFailure::NoVariantMatchedWithCauses(errs),
1045 ))
1046 })()
1047 .map_err(|e| e.annotate("DRep"))
1048 }
1049}
1050
1051impl Serialize for Ipv4 {
1052 fn serialize<'se, W: Write>(
1053 &self,
1054 serializer: &'se mut Serializer<W>,
1055 force_canonical: bool,
1056 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1057 serializer.write_bytes_sz(
1058 &self.inner,
1059 self.encodings
1060 .as_ref()
1061 .map(|encs| encs.inner_encoding.clone())
1062 .unwrap_or_default()
1063 .to_str_len_sz(self.inner.len() as u64, force_canonical),
1064 )
1065 }
1066}
1067
1068impl Deserialize for Ipv4 {
1069 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1070 let (inner, inner_encoding) = raw
1071 .bytes_sz()
1072 .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))?;
1073 if inner.len() != 4 {
1074 return Err(DeserializeError::new(
1075 "Ipv4",
1076 DeserializeFailure::RangeCheck {
1077 found: inner.len() as isize,
1078 min: Some(4),
1079 max: Some(4),
1080 },
1081 ));
1082 }
1083 Ok(Self {
1084 inner,
1085 encodings: Some(Ipv4Encoding { inner_encoding }),
1086 })
1087 }
1088}
1089
1090impl Serialize for Ipv6 {
1091 fn serialize<'se, W: Write>(
1092 &self,
1093 serializer: &'se mut Serializer<W>,
1094 force_canonical: bool,
1095 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1096 serializer.write_bytes_sz(
1097 &self.inner,
1098 self.encodings
1099 .as_ref()
1100 .map(|encs| encs.inner_encoding.clone())
1101 .unwrap_or_default()
1102 .to_str_len_sz(self.inner.len() as u64, force_canonical),
1103 )
1104 }
1105}
1106
1107impl Deserialize for Ipv6 {
1108 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1109 let (inner, inner_encoding) = raw
1110 .bytes_sz()
1111 .map(|(bytes, enc)| (bytes, StringEncoding::from(enc)))?;
1112 if inner.len() != 16 {
1113 return Err(DeserializeError::new(
1114 "Ipv6",
1115 DeserializeFailure::RangeCheck {
1116 found: inner.len() as isize,
1117 min: Some(16),
1118 max: Some(16),
1119 },
1120 ));
1121 }
1122 Ok(Self {
1123 inner,
1124 encodings: Some(Ipv6Encoding { inner_encoding }),
1125 })
1126 }
1127}
1128
1129impl Serialize for MultiHostName {
1130 fn serialize<'se, W: Write>(
1131 &self,
1132 serializer: &'se mut Serializer<W>,
1133 force_canonical: bool,
1134 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1135 serializer.write_array_sz(
1136 self.encodings
1137 .as_ref()
1138 .map(|encs| encs.len_encoding)
1139 .unwrap_or_default()
1140 .to_len_sz(2, force_canonical),
1141 )?;
1142 self.serialize_as_embedded_group(serializer, force_canonical)
1143 }
1144}
1145
1146impl SerializeEmbeddedGroup for MultiHostName {
1147 fn serialize_as_embedded_group<'se, W: Write>(
1148 &self,
1149 serializer: &'se mut Serializer<W>,
1150 force_canonical: bool,
1151 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1152 serializer.write_unsigned_integer_sz(
1153 2u64,
1154 fit_sz(
1155 2u64,
1156 self.encodings
1157 .as_ref()
1158 .map(|encs| encs.tag_encoding)
1159 .unwrap_or_default(),
1160 force_canonical,
1161 ),
1162 )?;
1163 self.dns_name.serialize(serializer, force_canonical)?;
1164 self.encodings
1165 .as_ref()
1166 .map(|encs| encs.len_encoding)
1167 .unwrap_or_default()
1168 .end(serializer, force_canonical)
1169 }
1170}
1171
1172impl Deserialize for MultiHostName {
1173 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1174 let len = raw.array_sz()?;
1175 let mut read_len = CBORReadLen::new(len);
1176 read_len.read_elems(2)?;
1177 read_len.finish()?;
1178 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1179 match len {
1180 cbor_event::LenSz::Len(_, _) => (),
1181 cbor_event::LenSz::Indefinite => match raw.special()? {
1182 cbor_event::Special::Break => (),
1183 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1184 },
1185 }
1186 ret
1187 }
1188}
1189
1190impl DeserializeEmbeddedGroup for MultiHostName {
1191 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1192 raw: &mut Deserializer<R>,
1193 _read_len: &mut CBORReadLen,
1194 len: cbor_event::LenSz,
1195 ) -> Result<Self, DeserializeError> {
1196 let len_encoding = len.into();
1197 (|| -> Result<_, DeserializeError> {
1198 let tag_encoding = (|| -> Result<_, DeserializeError> {
1199 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1200 if tag_value != 2 {
1201 return Err(DeserializeFailure::FixedValueMismatch {
1202 found: Key::Uint(tag_value),
1203 expected: Key::Uint(2),
1204 }
1205 .into());
1206 }
1207 Ok(Some(tag_encoding))
1208 })()
1209 .map_err(|e| e.annotate("tag"))?;
1210 let dns_name =
1211 DNSName::deserialize(raw).map_err(|e: DeserializeError| e.annotate("dns_name"))?;
1212 Ok(MultiHostName {
1213 dns_name,
1214 encodings: Some(MultiHostNameEncoding {
1215 len_encoding,
1216 tag_encoding,
1217 }),
1218 })
1219 })()
1220 .map_err(|e| e.annotate("MultiHostName"))
1221 }
1222}
1223
1224impl Serialize for PoolMetadata {
1225 fn serialize<'se, W: Write>(
1226 &self,
1227 serializer: &'se mut Serializer<W>,
1228 force_canonical: bool,
1229 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1230 serializer.write_array_sz(
1231 self.encodings
1232 .as_ref()
1233 .map(|encs| encs.len_encoding)
1234 .unwrap_or_default()
1235 .to_len_sz(2, force_canonical),
1236 )?;
1237 self.url.serialize(serializer, force_canonical)?;
1238 serializer.write_bytes_sz(
1239 self.pool_metadata_hash.to_raw_bytes(),
1240 self.encodings
1241 .as_ref()
1242 .map(|encs| encs.pool_metadata_hash_encoding.clone())
1243 .unwrap_or_default()
1244 .to_str_len_sz(
1245 self.pool_metadata_hash.to_raw_bytes().len() as u64,
1246 force_canonical,
1247 ),
1248 )?;
1249 self.encodings
1250 .as_ref()
1251 .map(|encs| encs.len_encoding)
1252 .unwrap_or_default()
1253 .end(serializer, force_canonical)
1254 }
1255}
1256
1257impl Deserialize for PoolMetadata {
1258 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1259 let len = raw.array_sz()?;
1260 let len_encoding: LenEncoding = len.into();
1261 let mut read_len = CBORReadLen::new(len);
1262 read_len.read_elems(2)?;
1263 read_len.finish()?;
1264 (|| -> Result<_, DeserializeError> {
1265 let url = Url::deserialize(raw).map_err(|e: DeserializeError| e.annotate("url"))?;
1266 let (pool_metadata_hash, pool_metadata_hash_encoding) = raw
1267 .bytes_sz()
1268 .map_err(Into::<DeserializeError>::into)
1269 .and_then(|(bytes, enc)| {
1270 PoolMetadataHash::from_raw_bytes(&bytes)
1271 .map(|bytes| (bytes, StringEncoding::from(enc)))
1272 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1273 })
1274 .map_err(|e: DeserializeError| e.annotate("pool_metadata_hash"))?;
1275 match len {
1276 cbor_event::LenSz::Len(_, _) => (),
1277 cbor_event::LenSz::Indefinite => match raw.special()? {
1278 cbor_event::Special::Break => (),
1279 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1280 },
1281 }
1282 Ok(PoolMetadata {
1283 url,
1284 pool_metadata_hash,
1285 encodings: Some(PoolMetadataEncoding {
1286 len_encoding,
1287 pool_metadata_hash_encoding,
1288 }),
1289 })
1290 })()
1291 .map_err(|e| e.annotate("PoolMetadata"))
1292 }
1293}
1294
1295impl Serialize for PoolParams {
1296 fn serialize<'se, W: Write>(
1297 &self,
1298 serializer: &'se mut Serializer<W>,
1299 force_canonical: bool,
1300 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1301 serializer.write_array_sz(
1302 self.encodings
1303 .as_ref()
1304 .map(|encs| encs.len_encoding)
1305 .unwrap_or_default()
1306 .to_len_sz(9, force_canonical),
1307 )?;
1308 self.serialize_as_embedded_group(serializer, force_canonical)
1309 }
1310}
1311
1312impl SerializeEmbeddedGroup for PoolParams {
1313 fn serialize_as_embedded_group<'se, W: Write>(
1314 &self,
1315 serializer: &'se mut Serializer<W>,
1316 force_canonical: bool,
1317 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1318 serializer.write_bytes_sz(
1319 self.operator.to_raw_bytes(),
1320 self.encodings
1321 .as_ref()
1322 .map(|encs| encs.operator_encoding.clone())
1323 .unwrap_or_default()
1324 .to_str_len_sz(self.operator.to_raw_bytes().len() as u64, force_canonical),
1325 )?;
1326 serializer.write_bytes_sz(
1327 self.vrf_keyhash.to_raw_bytes(),
1328 self.encodings
1329 .as_ref()
1330 .map(|encs| encs.vrf_keyhash_encoding.clone())
1331 .unwrap_or_default()
1332 .to_str_len_sz(
1333 self.vrf_keyhash.to_raw_bytes().len() as u64,
1334 force_canonical,
1335 ),
1336 )?;
1337 serializer.write_unsigned_integer_sz(
1338 self.pledge,
1339 fit_sz(
1340 self.pledge,
1341 self.encodings
1342 .as_ref()
1343 .map(|encs| encs.pledge_encoding)
1344 .unwrap_or_default(),
1345 force_canonical,
1346 ),
1347 )?;
1348 serializer.write_unsigned_integer_sz(
1349 self.cost,
1350 fit_sz(
1351 self.cost,
1352 self.encodings
1353 .as_ref()
1354 .map(|encs| encs.cost_encoding)
1355 .unwrap_or_default(),
1356 force_canonical,
1357 ),
1358 )?;
1359 self.margin.serialize(serializer, force_canonical)?;
1360 self.reward_account.serialize(serializer, force_canonical)?;
1361 self.pool_owners.serialize(serializer, force_canonical)?;
1362 serializer.write_array_sz(
1363 self.encodings
1364 .as_ref()
1365 .map(|encs| encs.relays_encoding)
1366 .unwrap_or_default()
1367 .to_len_sz(self.relays.len() as u64, force_canonical),
1368 )?;
1369 for element in self.relays.iter() {
1370 element.serialize(serializer, force_canonical)?;
1371 }
1372 self.encodings
1373 .as_ref()
1374 .map(|encs| encs.relays_encoding)
1375 .unwrap_or_default()
1376 .end(serializer, force_canonical)?;
1377 match &self.pool_metadata {
1378 Some(x) => x.serialize(serializer, force_canonical),
1379 None => serializer.write_special(cbor_event::Special::Null),
1380 }?;
1381 self.encodings
1382 .as_ref()
1383 .map(|encs| encs.len_encoding)
1384 .unwrap_or_default()
1385 .end(serializer, force_canonical)
1386 }
1387}
1388
1389impl Deserialize for PoolParams {
1390 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1391 let len = raw.array_sz()?;
1392 let mut read_len = CBORReadLen::new(len);
1393 read_len.read_elems(9)?;
1394 read_len.finish()?;
1395 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1396 match len {
1397 cbor_event::LenSz::Len(_, _) => (),
1398 cbor_event::LenSz::Indefinite => match raw.special()? {
1399 cbor_event::Special::Break => (),
1400 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1401 },
1402 }
1403 ret
1404 }
1405}
1406
1407impl DeserializeEmbeddedGroup for PoolParams {
1408 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1409 raw: &mut Deserializer<R>,
1410 _read_len: &mut CBORReadLen,
1411 len: cbor_event::LenSz,
1412 ) -> Result<Self, DeserializeError> {
1413 let len_encoding = len.into();
1414 (|| -> Result<_, DeserializeError> {
1415 let (operator, operator_encoding) = raw
1416 .bytes_sz()
1417 .map_err(Into::<DeserializeError>::into)
1418 .and_then(|(bytes, enc)| {
1419 Ed25519KeyHash::from_raw_bytes(&bytes)
1420 .map(|bytes| (bytes, StringEncoding::from(enc)))
1421 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1422 })
1423 .map_err(|e: DeserializeError| e.annotate("operator"))?;
1424 let (vrf_keyhash, vrf_keyhash_encoding) = raw
1425 .bytes_sz()
1426 .map_err(Into::<DeserializeError>::into)
1427 .and_then(|(bytes, enc)| {
1428 VRFKeyHash::from_raw_bytes(&bytes)
1429 .map(|bytes| (bytes, StringEncoding::from(enc)))
1430 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1431 })
1432 .map_err(|e: DeserializeError| e.annotate("vrf_keyhash"))?;
1433 let (pledge, pledge_encoding) = raw
1434 .unsigned_integer_sz()
1435 .map_err(Into::<DeserializeError>::into)
1436 .map(|(x, enc)| (x, Some(enc)))
1437 .map_err(|e: DeserializeError| e.annotate("pledge"))?;
1438 let (cost, cost_encoding) = raw
1439 .unsigned_integer_sz()
1440 .map_err(Into::<DeserializeError>::into)
1441 .map(|(x, enc)| (x, Some(enc)))
1442 .map_err(|e: DeserializeError| e.annotate("cost"))?;
1443 let margin = UnitInterval::deserialize(raw)
1444 .map_err(|e: DeserializeError| e.annotate("margin"))?;
1445 let reward_account = RewardAccount::deserialize(raw)
1446 .map_err(|e: DeserializeError| e.annotate("reward_account"))?;
1447 let pool_owners = SetEd25519KeyHash::deserialize(raw)
1448 .map_err(|e: DeserializeError| e.annotate("pool_owners"))?;
1449 let (relays, relays_encoding) = (|| -> Result<_, DeserializeError> {
1450 let mut relays_arr = Vec::new();
1451 let len = raw.array_sz()?;
1452 let relays_encoding = len.into();
1453 while match len {
1454 cbor_event::LenSz::Len(n, _) => (relays_arr.len() as u64) < n,
1455 cbor_event::LenSz::Indefinite => true,
1456 } {
1457 if raw.cbor_type()? == cbor_event::Type::Special {
1458 assert_eq!(raw.special()?, cbor_event::Special::Break);
1459 break;
1460 }
1461 relays_arr.push(Relay::deserialize(raw)?);
1462 }
1463 Ok((relays_arr, relays_encoding))
1464 })()
1465 .map_err(|e| e.annotate("relays"))?;
1466 let pool_metadata = (|| -> Result<_, DeserializeError> {
1467 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1468 true => Some(PoolMetadata::deserialize(raw)?),
1469 false => {
1470 if raw.special()? != cbor_event::Special::Null {
1471 return Err(DeserializeFailure::ExpectedNull.into());
1472 }
1473 None
1474 }
1475 })
1476 })()
1477 .map_err(|e| e.annotate("pool_metadata"))?;
1478 Ok(PoolParams {
1479 operator,
1480 vrf_keyhash,
1481 pledge,
1482 cost,
1483 margin,
1484 reward_account,
1485 pool_owners,
1486 relays,
1487 pool_metadata,
1488 encodings: Some(PoolParamsEncoding {
1489 len_encoding,
1490 operator_encoding,
1491 vrf_keyhash_encoding,
1492 pledge_encoding,
1493 cost_encoding,
1494 relays_encoding,
1495 }),
1496 })
1497 })()
1498 .map_err(|e| e.annotate("PoolParams"))
1499 }
1500}
1501
1502impl Serialize for PoolRegistration {
1503 fn serialize<'se, W: Write>(
1504 &self,
1505 serializer: &'se mut Serializer<W>,
1506 force_canonical: bool,
1507 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1508 serializer.write_array_sz(
1509 self.encodings
1510 .as_ref()
1511 .map(|encs| encs.len_encoding)
1512 .unwrap_or_default()
1513 .to_len_sz(10, force_canonical),
1514 )?;
1515 self.serialize_as_embedded_group(serializer, force_canonical)
1516 }
1517}
1518
1519impl SerializeEmbeddedGroup for PoolRegistration {
1520 fn serialize_as_embedded_group<'se, W: Write>(
1521 &self,
1522 serializer: &'se mut Serializer<W>,
1523 force_canonical: bool,
1524 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1525 serializer.write_unsigned_integer_sz(
1526 3u64,
1527 fit_sz(
1528 3u64,
1529 self.encodings
1530 .as_ref()
1531 .map(|encs| encs.tag_encoding)
1532 .unwrap_or_default(),
1533 force_canonical,
1534 ),
1535 )?;
1536 self.pool_params
1537 .serialize_as_embedded_group(serializer, force_canonical)?;
1538 self.encodings
1539 .as_ref()
1540 .map(|encs| encs.len_encoding)
1541 .unwrap_or_default()
1542 .end(serializer, force_canonical)
1543 }
1544}
1545
1546impl Deserialize for PoolRegistration {
1547 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1548 let len = raw.array_sz()?;
1549 let mut read_len = CBORReadLen::new(len);
1550 read_len.read_elems(10)?;
1551 read_len.finish()?;
1552 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1553 match len {
1554 cbor_event::LenSz::Len(_, _) => (),
1555 cbor_event::LenSz::Indefinite => match raw.special()? {
1556 cbor_event::Special::Break => (),
1557 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1558 },
1559 }
1560 ret
1561 }
1562}
1563
1564impl DeserializeEmbeddedGroup for PoolRegistration {
1565 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1566 raw: &mut Deserializer<R>,
1567 read_len: &mut CBORReadLen,
1568 len: cbor_event::LenSz,
1569 ) -> Result<Self, DeserializeError> {
1570 let len_encoding = len.into();
1571 (|| -> Result<_, DeserializeError> {
1572 let tag_encoding = (|| -> Result<_, DeserializeError> {
1573 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1574 if tag_value != 3 {
1575 return Err(DeserializeFailure::FixedValueMismatch {
1576 found: Key::Uint(tag_value),
1577 expected: Key::Uint(3),
1578 }
1579 .into());
1580 }
1581 Ok(Some(tag_encoding))
1582 })()
1583 .map_err(|e| e.annotate("tag"))?;
1584 let pool_params = PoolParams::deserialize_as_embedded_group(raw, read_len, len)
1585 .map_err(|e: DeserializeError| e.annotate("pool_params"))?;
1586 Ok(PoolRegistration {
1587 pool_params,
1588 encodings: Some(PoolRegistrationEncoding {
1589 len_encoding,
1590 tag_encoding,
1591 }),
1592 })
1593 })()
1594 .map_err(|e| e.annotate("PoolRegistration"))
1595 }
1596}
1597
1598impl Serialize for PoolRetirement {
1599 fn serialize<'se, W: Write>(
1600 &self,
1601 serializer: &'se mut Serializer<W>,
1602 force_canonical: bool,
1603 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1604 serializer.write_array_sz(
1605 self.encodings
1606 .as_ref()
1607 .map(|encs| encs.len_encoding)
1608 .unwrap_or_default()
1609 .to_len_sz(3, force_canonical),
1610 )?;
1611 self.serialize_as_embedded_group(serializer, force_canonical)
1612 }
1613}
1614
1615impl SerializeEmbeddedGroup for PoolRetirement {
1616 fn serialize_as_embedded_group<'se, W: Write>(
1617 &self,
1618 serializer: &'se mut Serializer<W>,
1619 force_canonical: bool,
1620 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1621 serializer.write_unsigned_integer_sz(
1622 4u64,
1623 fit_sz(
1624 4u64,
1625 self.encodings
1626 .as_ref()
1627 .map(|encs| encs.tag_encoding)
1628 .unwrap_or_default(),
1629 force_canonical,
1630 ),
1631 )?;
1632 serializer.write_bytes_sz(
1633 self.pool.to_raw_bytes(),
1634 self.encodings
1635 .as_ref()
1636 .map(|encs| encs.pool_encoding.clone())
1637 .unwrap_or_default()
1638 .to_str_len_sz(self.pool.to_raw_bytes().len() as u64, force_canonical),
1639 )?;
1640 serializer.write_unsigned_integer_sz(
1641 self.epoch,
1642 fit_sz(
1643 self.epoch,
1644 self.encodings
1645 .as_ref()
1646 .map(|encs| encs.epoch_encoding)
1647 .unwrap_or_default(),
1648 force_canonical,
1649 ),
1650 )?;
1651 self.encodings
1652 .as_ref()
1653 .map(|encs| encs.len_encoding)
1654 .unwrap_or_default()
1655 .end(serializer, force_canonical)
1656 }
1657}
1658
1659impl Deserialize for PoolRetirement {
1660 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1661 let len = raw.array_sz()?;
1662 let mut read_len = CBORReadLen::new(len);
1663 read_len.read_elems(3)?;
1664 read_len.finish()?;
1665 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1666 match len {
1667 cbor_event::LenSz::Len(_, _) => (),
1668 cbor_event::LenSz::Indefinite => match raw.special()? {
1669 cbor_event::Special::Break => (),
1670 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1671 },
1672 }
1673 ret
1674 }
1675}
1676
1677impl DeserializeEmbeddedGroup for PoolRetirement {
1678 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1679 raw: &mut Deserializer<R>,
1680 _read_len: &mut CBORReadLen,
1681 len: cbor_event::LenSz,
1682 ) -> Result<Self, DeserializeError> {
1683 let len_encoding = len.into();
1684 (|| -> Result<_, DeserializeError> {
1685 let tag_encoding = (|| -> Result<_, DeserializeError> {
1686 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1687 if tag_value != 4 {
1688 return Err(DeserializeFailure::FixedValueMismatch {
1689 found: Key::Uint(tag_value),
1690 expected: Key::Uint(4),
1691 }
1692 .into());
1693 }
1694 Ok(Some(tag_encoding))
1695 })()
1696 .map_err(|e| e.annotate("tag"))?;
1697 let (pool, pool_encoding) = raw
1698 .bytes_sz()
1699 .map_err(Into::<DeserializeError>::into)
1700 .and_then(|(bytes, enc)| {
1701 Ed25519KeyHash::from_raw_bytes(&bytes)
1702 .map(|bytes| (bytes, StringEncoding::from(enc)))
1703 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
1704 })
1705 .map_err(|e: DeserializeError| e.annotate("pool"))?;
1706 let (epoch, epoch_encoding) = raw
1707 .unsigned_integer_sz()
1708 .map_err(Into::<DeserializeError>::into)
1709 .map(|(x, enc)| (x, Some(enc)))
1710 .map_err(|e: DeserializeError| e.annotate("epoch"))?;
1711 Ok(PoolRetirement {
1712 pool,
1713 epoch,
1714 encodings: Some(PoolRetirementEncoding {
1715 len_encoding,
1716 tag_encoding,
1717 pool_encoding,
1718 epoch_encoding,
1719 }),
1720 })
1721 })()
1722 .map_err(|e| e.annotate("PoolRetirement"))
1723 }
1724}
1725
1726impl Serialize for RegCert {
1727 fn serialize<'se, W: Write>(
1728 &self,
1729 serializer: &'se mut Serializer<W>,
1730 force_canonical: bool,
1731 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1732 serializer.write_array_sz(
1733 self.encodings
1734 .as_ref()
1735 .map(|encs| encs.len_encoding)
1736 .unwrap_or_default()
1737 .to_len_sz(3, force_canonical),
1738 )?;
1739 self.serialize_as_embedded_group(serializer, force_canonical)
1740 }
1741}
1742
1743impl SerializeEmbeddedGroup for RegCert {
1744 fn serialize_as_embedded_group<'se, W: Write>(
1745 &self,
1746 serializer: &'se mut Serializer<W>,
1747 force_canonical: bool,
1748 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1749 serializer.write_unsigned_integer_sz(
1750 7u64,
1751 fit_sz(
1752 7u64,
1753 self.encodings
1754 .as_ref()
1755 .map(|encs| encs.tag_encoding)
1756 .unwrap_or_default(),
1757 force_canonical,
1758 ),
1759 )?;
1760 self.stake_credential
1761 .serialize(serializer, force_canonical)?;
1762 serializer.write_unsigned_integer_sz(
1763 self.deposit,
1764 fit_sz(
1765 self.deposit,
1766 self.encodings
1767 .as_ref()
1768 .map(|encs| encs.deposit_encoding)
1769 .unwrap_or_default(),
1770 force_canonical,
1771 ),
1772 )?;
1773 self.encodings
1774 .as_ref()
1775 .map(|encs| encs.len_encoding)
1776 .unwrap_or_default()
1777 .end(serializer, force_canonical)
1778 }
1779}
1780
1781impl Deserialize for RegCert {
1782 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1783 let len = raw.array_sz()?;
1784 let mut read_len = CBORReadLen::new(len);
1785 read_len.read_elems(3)?;
1786 read_len.finish()?;
1787 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1788 match len {
1789 cbor_event::LenSz::Len(_, _) => (),
1790 cbor_event::LenSz::Indefinite => match raw.special()? {
1791 cbor_event::Special::Break => (),
1792 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1793 },
1794 }
1795 ret
1796 }
1797}
1798
1799impl DeserializeEmbeddedGroup for RegCert {
1800 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1801 raw: &mut Deserializer<R>,
1802 _read_len: &mut CBORReadLen,
1803 len: cbor_event::LenSz,
1804 ) -> Result<Self, DeserializeError> {
1805 let len_encoding = len.into();
1806 (|| -> Result<_, DeserializeError> {
1807 let tag_encoding = (|| -> Result<_, DeserializeError> {
1808 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
1809 if tag_value != 7 {
1810 return Err(DeserializeFailure::FixedValueMismatch {
1811 found: Key::Uint(tag_value),
1812 expected: Key::Uint(7),
1813 }
1814 .into());
1815 }
1816 Ok(Some(tag_encoding))
1817 })()
1818 .map_err(|e| e.annotate("tag"))?;
1819 let stake_credential = Credential::deserialize(raw)
1820 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
1821 let (deposit, deposit_encoding) = raw
1822 .unsigned_integer_sz()
1823 .map_err(Into::<DeserializeError>::into)
1824 .map(|(x, enc)| (x, Some(enc)))
1825 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
1826 Ok(RegCert {
1827 stake_credential,
1828 deposit,
1829 encodings: Some(RegCertEncoding {
1830 len_encoding,
1831 tag_encoding,
1832 deposit_encoding,
1833 }),
1834 })
1835 })()
1836 .map_err(|e| e.annotate("RegCert"))
1837 }
1838}
1839
1840impl Serialize for RegDrepCert {
1841 fn serialize<'se, W: Write>(
1842 &self,
1843 serializer: &'se mut Serializer<W>,
1844 force_canonical: bool,
1845 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1846 serializer.write_array_sz(
1847 self.encodings
1848 .as_ref()
1849 .map(|encs| encs.len_encoding)
1850 .unwrap_or_default()
1851 .to_len_sz(4, force_canonical),
1852 )?;
1853 self.serialize_as_embedded_group(serializer, force_canonical)
1854 }
1855}
1856
1857impl SerializeEmbeddedGroup for RegDrepCert {
1858 fn serialize_as_embedded_group<'se, W: Write>(
1859 &self,
1860 serializer: &'se mut Serializer<W>,
1861 force_canonical: bool,
1862 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1863 serializer.write_unsigned_integer_sz(
1864 16u64,
1865 fit_sz(
1866 16u64,
1867 self.encodings
1868 .as_ref()
1869 .map(|encs| encs.index_0_encoding)
1870 .unwrap_or_default(),
1871 force_canonical,
1872 ),
1873 )?;
1874 self.drep_credential
1875 .serialize(serializer, force_canonical)?;
1876 serializer.write_unsigned_integer_sz(
1877 self.deposit,
1878 fit_sz(
1879 self.deposit,
1880 self.encodings
1881 .as_ref()
1882 .map(|encs| encs.deposit_encoding)
1883 .unwrap_or_default(),
1884 force_canonical,
1885 ),
1886 )?;
1887 match &self.anchor {
1888 Some(x) => x.serialize(serializer, force_canonical),
1889 None => serializer.write_special(cbor_event::Special::Null),
1890 }?;
1891 self.encodings
1892 .as_ref()
1893 .map(|encs| encs.len_encoding)
1894 .unwrap_or_default()
1895 .end(serializer, force_canonical)
1896 }
1897}
1898
1899impl Deserialize for RegDrepCert {
1900 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1901 let len = raw.array_sz()?;
1902 let mut read_len = CBORReadLen::new(len);
1903 read_len.read_elems(4)?;
1904 read_len.finish()?;
1905 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
1906 match len {
1907 cbor_event::LenSz::Len(_, _) => (),
1908 cbor_event::LenSz::Indefinite => match raw.special()? {
1909 cbor_event::Special::Break => (),
1910 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
1911 },
1912 }
1913 ret
1914 }
1915}
1916
1917impl DeserializeEmbeddedGroup for RegDrepCert {
1918 fn deserialize_as_embedded_group<R: BufRead + Seek>(
1919 raw: &mut Deserializer<R>,
1920 _read_len: &mut CBORReadLen,
1921 len: cbor_event::LenSz,
1922 ) -> Result<Self, DeserializeError> {
1923 let len_encoding = len.into();
1924 (|| -> Result<_, DeserializeError> {
1925 let index_0_encoding = (|| -> Result<_, DeserializeError> {
1926 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
1927 if index_0_value != 16 {
1928 return Err(DeserializeFailure::FixedValueMismatch {
1929 found: Key::Uint(index_0_value),
1930 expected: Key::Uint(16),
1931 }
1932 .into());
1933 }
1934 Ok(Some(index_0_encoding))
1935 })()
1936 .map_err(|e| e.annotate("index_0"))?;
1937 let drep_credential = Credential::deserialize(raw)
1938 .map_err(|e: DeserializeError| e.annotate("drep_credential"))?;
1939 let (deposit, deposit_encoding) = raw
1940 .unsigned_integer_sz()
1941 .map_err(Into::<DeserializeError>::into)
1942 .map(|(x, enc)| (x, Some(enc)))
1943 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
1944 let anchor = (|| -> Result<_, DeserializeError> {
1945 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
1946 true => Some(Anchor::deserialize(raw)?),
1947 false => {
1948 if raw.special()? != cbor_event::Special::Null {
1949 return Err(DeserializeFailure::ExpectedNull.into());
1950 }
1951 None
1952 }
1953 })
1954 })()
1955 .map_err(|e| e.annotate("anchor"))?;
1956 Ok(RegDrepCert {
1957 drep_credential,
1958 deposit,
1959 anchor,
1960 encodings: Some(RegDrepCertEncoding {
1961 len_encoding,
1962 index_0_encoding,
1963 deposit_encoding,
1964 }),
1965 })
1966 })()
1967 .map_err(|e| e.annotate("RegDrepCert"))
1968 }
1969}
1970
1971impl Serialize for Relay {
1972 fn serialize<'se, W: Write>(
1973 &self,
1974 serializer: &'se mut Serializer<W>,
1975 force_canonical: bool,
1976 ) -> cbor_event::Result<&'se mut Serializer<W>> {
1977 match self {
1978 Relay::SingleHostAddr(single_host_addr) => {
1979 single_host_addr.serialize(serializer, force_canonical)
1980 }
1981 Relay::SingleHostName(single_host_name) => {
1982 single_host_name.serialize(serializer, force_canonical)
1983 }
1984 Relay::MultiHostName(multi_host_name) => {
1985 multi_host_name.serialize(serializer, force_canonical)
1986 }
1987 }
1988 }
1989}
1990
1991impl Deserialize for Relay {
1992 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
1993 (|| -> Result<_, DeserializeError> {
1994 let len = raw.array_sz()?;
1995 let initial_position = raw.as_mut_ref().stream_position().unwrap();
1996 let mut errs = Vec::new();
1997 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
1998 let mut read_len = CBORReadLen::new(len);
1999 read_len.read_elems(4)?;
2000 read_len.finish()?;
2001 let ret = SingleHostAddr::deserialize_as_embedded_group(raw, &mut read_len, len);
2002 match len {
2003 cbor_event::LenSz::Len(_, _) => (),
2004 cbor_event::LenSz::Indefinite => match raw.special()? {
2005 cbor_event::Special::Break => (),
2006 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2007 },
2008 }
2009 ret
2010 })(raw);
2011 match deser_variant {
2012 Ok(single_host_addr) => return Ok(Self::SingleHostAddr(single_host_addr)),
2013 Err(e) => {
2014 errs.push(e.annotate("SingleHostAddr"));
2015 raw.as_mut_ref()
2016 .seek(SeekFrom::Start(initial_position))
2017 .unwrap();
2018 }
2019 };
2020 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
2021 let mut read_len = CBORReadLen::new(len);
2022 read_len.read_elems(3)?;
2023 read_len.finish()?;
2024 let ret = SingleHostName::deserialize_as_embedded_group(raw, &mut read_len, len);
2025 match len {
2026 cbor_event::LenSz::Len(_, _) => (),
2027 cbor_event::LenSz::Indefinite => match raw.special()? {
2028 cbor_event::Special::Break => (),
2029 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2030 },
2031 }
2032 ret
2033 })(raw);
2034 match deser_variant {
2035 Ok(single_host_name) => return Ok(Self::SingleHostName(single_host_name)),
2036 Err(e) => {
2037 errs.push(e.annotate("SingleHostName"));
2038 raw.as_mut_ref()
2039 .seek(SeekFrom::Start(initial_position))
2040 .unwrap();
2041 }
2042 };
2043 let deser_variant = (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
2044 let mut read_len = CBORReadLen::new(len);
2045 read_len.read_elems(2)?;
2046 read_len.finish()?;
2047 let ret = MultiHostName::deserialize_as_embedded_group(raw, &mut read_len, len);
2048 match len {
2049 cbor_event::LenSz::Len(_, _) => (),
2050 cbor_event::LenSz::Indefinite => match raw.special()? {
2051 cbor_event::Special::Break => (),
2052 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2053 },
2054 }
2055 ret
2056 })(raw);
2057 match deser_variant {
2058 Ok(multi_host_name) => return Ok(Self::MultiHostName(multi_host_name)),
2059 Err(e) => {
2060 errs.push(e.annotate("MultiHostName"));
2061 raw.as_mut_ref()
2062 .seek(SeekFrom::Start(initial_position))
2063 .unwrap();
2064 }
2065 };
2066 Err(DeserializeError::new(
2067 "Relay",
2068 DeserializeFailure::NoVariantMatchedWithCauses(errs),
2069 ))
2070 })()
2071 .map_err(|e| e.annotate("Relay"))
2072 }
2073}
2074
2075impl Serialize for ResignCommitteeColdCert {
2076 fn serialize<'se, W: Write>(
2077 &self,
2078 serializer: &'se mut Serializer<W>,
2079 force_canonical: bool,
2080 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2081 serializer.write_array_sz(
2082 self.encodings
2083 .as_ref()
2084 .map(|encs| encs.len_encoding)
2085 .unwrap_or_default()
2086 .to_len_sz(3, force_canonical),
2087 )?;
2088 self.serialize_as_embedded_group(serializer, force_canonical)
2089 }
2090}
2091
2092impl SerializeEmbeddedGroup for ResignCommitteeColdCert {
2093 fn serialize_as_embedded_group<'se, W: Write>(
2094 &self,
2095 serializer: &'se mut Serializer<W>,
2096 force_canonical: bool,
2097 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2098 serializer.write_unsigned_integer_sz(
2099 15u64,
2100 fit_sz(
2101 15u64,
2102 self.encodings
2103 .as_ref()
2104 .map(|encs| encs.index_0_encoding)
2105 .unwrap_or_default(),
2106 force_canonical,
2107 ),
2108 )?;
2109 self.committee_cold_credential
2110 .serialize(serializer, force_canonical)?;
2111 match &self.anchor {
2112 Some(x) => x.serialize(serializer, force_canonical),
2113 None => serializer.write_special(cbor_event::Special::Null),
2114 }?;
2115 self.encodings
2116 .as_ref()
2117 .map(|encs| encs.len_encoding)
2118 .unwrap_or_default()
2119 .end(serializer, force_canonical)
2120 }
2121}
2122
2123impl Deserialize for ResignCommitteeColdCert {
2124 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2125 let len = raw.array_sz()?;
2126 let mut read_len = CBORReadLen::new(len);
2127 read_len.read_elems(3)?;
2128 read_len.finish()?;
2129 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2130 match len {
2131 cbor_event::LenSz::Len(_, _) => (),
2132 cbor_event::LenSz::Indefinite => match raw.special()? {
2133 cbor_event::Special::Break => (),
2134 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2135 },
2136 }
2137 ret
2138 }
2139}
2140
2141impl DeserializeEmbeddedGroup for ResignCommitteeColdCert {
2142 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2143 raw: &mut Deserializer<R>,
2144 _read_len: &mut CBORReadLen,
2145 len: cbor_event::LenSz,
2146 ) -> Result<Self, DeserializeError> {
2147 let len_encoding = len.into();
2148 (|| -> Result<_, DeserializeError> {
2149 let index_0_encoding = (|| -> Result<_, DeserializeError> {
2150 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
2151 if index_0_value != 15 {
2152 return Err(DeserializeFailure::FixedValueMismatch {
2153 found: Key::Uint(index_0_value),
2154 expected: Key::Uint(15),
2155 }
2156 .into());
2157 }
2158 Ok(Some(index_0_encoding))
2159 })()
2160 .map_err(|e| e.annotate("index_0"))?;
2161 let committee_cold_credential = Credential::deserialize(raw)
2162 .map_err(|e: DeserializeError| e.annotate("committee_cold_credential"))?;
2163 let anchor = (|| -> Result<_, DeserializeError> {
2164 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2165 true => Some(Anchor::deserialize(raw)?),
2166 false => {
2167 if raw.special()? != cbor_event::Special::Null {
2168 return Err(DeserializeFailure::ExpectedNull.into());
2169 }
2170 None
2171 }
2172 })
2173 })()
2174 .map_err(|e| e.annotate("anchor"))?;
2175 Ok(ResignCommitteeColdCert {
2176 committee_cold_credential,
2177 anchor,
2178 encodings: Some(ResignCommitteeColdCertEncoding {
2179 len_encoding,
2180 index_0_encoding,
2181 }),
2182 })
2183 })()
2184 .map_err(|e| e.annotate("ResignCommitteeColdCert"))
2185 }
2186}
2187
2188impl Serialize for SingleHostAddr {
2189 fn serialize<'se, W: Write>(
2190 &self,
2191 serializer: &'se mut Serializer<W>,
2192 force_canonical: bool,
2193 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2194 serializer.write_array_sz(
2195 self.encodings
2196 .as_ref()
2197 .map(|encs| encs.len_encoding)
2198 .unwrap_or_default()
2199 .to_len_sz(4, force_canonical),
2200 )?;
2201 self.serialize_as_embedded_group(serializer, force_canonical)
2202 }
2203}
2204
2205impl SerializeEmbeddedGroup for SingleHostAddr {
2206 fn serialize_as_embedded_group<'se, W: Write>(
2207 &self,
2208 serializer: &'se mut Serializer<W>,
2209 force_canonical: bool,
2210 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2211 serializer.write_unsigned_integer_sz(
2212 0u64,
2213 fit_sz(
2214 0u64,
2215 self.encodings
2216 .as_ref()
2217 .map(|encs| encs.tag_encoding)
2218 .unwrap_or_default(),
2219 force_canonical,
2220 ),
2221 )?;
2222 match &self.port {
2223 Some(x) => serializer.write_unsigned_integer_sz(
2224 *x as u64,
2225 fit_sz(
2226 *x as u64,
2227 self.encodings
2228 .as_ref()
2229 .map(|encs| encs.port_encoding)
2230 .unwrap_or_default(),
2231 force_canonical,
2232 ),
2233 ),
2234 None => serializer.write_special(cbor_event::Special::Null),
2235 }?;
2236 match &self.ipv4 {
2237 Some(x) => x.serialize(serializer, force_canonical),
2238 None => serializer.write_special(cbor_event::Special::Null),
2239 }?;
2240 match &self.ipv6 {
2241 Some(x) => x.serialize(serializer, force_canonical),
2242 None => serializer.write_special(cbor_event::Special::Null),
2243 }?;
2244 self.encodings
2245 .as_ref()
2246 .map(|encs| encs.len_encoding)
2247 .unwrap_or_default()
2248 .end(serializer, force_canonical)
2249 }
2250}
2251
2252impl Deserialize for SingleHostAddr {
2253 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2254 let len = raw.array_sz()?;
2255 let mut read_len = CBORReadLen::new(len);
2256 read_len.read_elems(4)?;
2257 read_len.finish()?;
2258 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2259 match len {
2260 cbor_event::LenSz::Len(_, _) => (),
2261 cbor_event::LenSz::Indefinite => match raw.special()? {
2262 cbor_event::Special::Break => (),
2263 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2264 },
2265 }
2266 ret
2267 }
2268}
2269
2270impl DeserializeEmbeddedGroup for SingleHostAddr {
2271 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2272 raw: &mut Deserializer<R>,
2273 _read_len: &mut CBORReadLen,
2274 len: cbor_event::LenSz,
2275 ) -> Result<Self, DeserializeError> {
2276 let len_encoding = len.into();
2277 (|| -> Result<_, DeserializeError> {
2278 let tag_encoding = (|| -> Result<_, DeserializeError> {
2279 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2280 if tag_value != 0 {
2281 return Err(DeserializeFailure::FixedValueMismatch {
2282 found: Key::Uint(tag_value),
2283 expected: Key::Uint(0),
2284 }
2285 .into());
2286 }
2287 Ok(Some(tag_encoding))
2288 })()
2289 .map_err(|e| e.annotate("tag"))?;
2290 let (port, port_encoding) = (|| -> Result<_, DeserializeError> {
2291 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2292 true => Result::<_, DeserializeError>::Ok(
2293 raw.unsigned_integer_sz()
2294 .map(|(x, enc)| (x as u16, Some(enc)))?,
2295 )
2296 .map(|(x, port_encoding)| (Some(x), port_encoding))?,
2297 false => {
2298 if raw.special()? != cbor_event::Special::Null {
2299 return Err(DeserializeFailure::ExpectedNull.into());
2300 }
2301 (None, None)
2302 }
2303 })
2304 })()
2305 .map_err(|e| e.annotate("port"))?;
2306 let ipv4 = (|| -> Result<_, DeserializeError> {
2307 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2308 true => Some(Ipv4::deserialize(raw)?),
2309 false => {
2310 if raw.special()? != cbor_event::Special::Null {
2311 return Err(DeserializeFailure::ExpectedNull.into());
2312 }
2313 None
2314 }
2315 })
2316 })()
2317 .map_err(|e| e.annotate("ipv4"))?;
2318 let ipv6 = (|| -> Result<_, DeserializeError> {
2319 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2320 true => Some(Ipv6::deserialize(raw)?),
2321 false => {
2322 if raw.special()? != cbor_event::Special::Null {
2323 return Err(DeserializeFailure::ExpectedNull.into());
2324 }
2325 None
2326 }
2327 })
2328 })()
2329 .map_err(|e| e.annotate("ipv6"))?;
2330 Ok(SingleHostAddr {
2331 port,
2332 ipv4,
2333 ipv6,
2334 encodings: Some(SingleHostAddrEncoding {
2335 len_encoding,
2336 tag_encoding,
2337 port_encoding,
2338 }),
2339 })
2340 })()
2341 .map_err(|e| e.annotate("SingleHostAddr"))
2342 }
2343}
2344
2345impl Serialize for SingleHostName {
2346 fn serialize<'se, W: Write>(
2347 &self,
2348 serializer: &'se mut Serializer<W>,
2349 force_canonical: bool,
2350 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2351 serializer.write_array_sz(
2352 self.encodings
2353 .as_ref()
2354 .map(|encs| encs.len_encoding)
2355 .unwrap_or_default()
2356 .to_len_sz(3, force_canonical),
2357 )?;
2358 self.serialize_as_embedded_group(serializer, force_canonical)
2359 }
2360}
2361
2362impl SerializeEmbeddedGroup for SingleHostName {
2363 fn serialize_as_embedded_group<'se, W: Write>(
2364 &self,
2365 serializer: &'se mut Serializer<W>,
2366 force_canonical: bool,
2367 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2368 serializer.write_unsigned_integer_sz(
2369 1u64,
2370 fit_sz(
2371 1u64,
2372 self.encodings
2373 .as_ref()
2374 .map(|encs| encs.tag_encoding)
2375 .unwrap_or_default(),
2376 force_canonical,
2377 ),
2378 )?;
2379 match &self.port {
2380 Some(x) => serializer.write_unsigned_integer_sz(
2381 *x as u64,
2382 fit_sz(
2383 *x as u64,
2384 self.encodings
2385 .as_ref()
2386 .map(|encs| encs.port_encoding)
2387 .unwrap_or_default(),
2388 force_canonical,
2389 ),
2390 ),
2391 None => serializer.write_special(cbor_event::Special::Null),
2392 }?;
2393 self.dns_name.serialize(serializer, force_canonical)?;
2394 self.encodings
2395 .as_ref()
2396 .map(|encs| encs.len_encoding)
2397 .unwrap_or_default()
2398 .end(serializer, force_canonical)
2399 }
2400}
2401
2402impl Deserialize for SingleHostName {
2403 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2404 let len = raw.array_sz()?;
2405 let mut read_len = CBORReadLen::new(len);
2406 read_len.read_elems(3)?;
2407 read_len.finish()?;
2408 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2409 match len {
2410 cbor_event::LenSz::Len(_, _) => (),
2411 cbor_event::LenSz::Indefinite => match raw.special()? {
2412 cbor_event::Special::Break => (),
2413 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2414 },
2415 }
2416 ret
2417 }
2418}
2419
2420impl DeserializeEmbeddedGroup for SingleHostName {
2421 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2422 raw: &mut Deserializer<R>,
2423 _read_len: &mut CBORReadLen,
2424 len: cbor_event::LenSz,
2425 ) -> Result<Self, DeserializeError> {
2426 let len_encoding = len.into();
2427 (|| -> Result<_, DeserializeError> {
2428 let tag_encoding = (|| -> Result<_, DeserializeError> {
2429 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2430 if tag_value != 1 {
2431 return Err(DeserializeFailure::FixedValueMismatch {
2432 found: Key::Uint(tag_value),
2433 expected: Key::Uint(1),
2434 }
2435 .into());
2436 }
2437 Ok(Some(tag_encoding))
2438 })()
2439 .map_err(|e| e.annotate("tag"))?;
2440 let (port, port_encoding) = (|| -> Result<_, DeserializeError> {
2441 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
2442 true => Result::<_, DeserializeError>::Ok(
2443 raw.unsigned_integer_sz()
2444 .map(|(x, enc)| (x as u16, Some(enc)))?,
2445 )
2446 .map(|(x, port_encoding)| (Some(x), port_encoding))?,
2447 false => {
2448 if raw.special()? != cbor_event::Special::Null {
2449 return Err(DeserializeFailure::ExpectedNull.into());
2450 }
2451 (None, None)
2452 }
2453 })
2454 })()
2455 .map_err(|e| e.annotate("port"))?;
2456 let dns_name =
2457 DNSName::deserialize(raw).map_err(|e: DeserializeError| e.annotate("dns_name"))?;
2458 Ok(SingleHostName {
2459 port,
2460 dns_name,
2461 encodings: Some(SingleHostNameEncoding {
2462 len_encoding,
2463 tag_encoding,
2464 port_encoding,
2465 }),
2466 })
2467 })()
2468 .map_err(|e| e.annotate("SingleHostName"))
2469 }
2470}
2471
2472impl Serialize for StakeDelegation {
2473 fn serialize<'se, W: Write>(
2474 &self,
2475 serializer: &'se mut Serializer<W>,
2476 force_canonical: bool,
2477 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2478 serializer.write_array_sz(
2479 self.encodings
2480 .as_ref()
2481 .map(|encs| encs.len_encoding)
2482 .unwrap_or_default()
2483 .to_len_sz(3, force_canonical),
2484 )?;
2485 self.serialize_as_embedded_group(serializer, force_canonical)
2486 }
2487}
2488
2489impl SerializeEmbeddedGroup for StakeDelegation {
2490 fn serialize_as_embedded_group<'se, W: Write>(
2491 &self,
2492 serializer: &'se mut Serializer<W>,
2493 force_canonical: bool,
2494 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2495 serializer.write_unsigned_integer_sz(
2496 2u64,
2497 fit_sz(
2498 2u64,
2499 self.encodings
2500 .as_ref()
2501 .map(|encs| encs.tag_encoding)
2502 .unwrap_or_default(),
2503 force_canonical,
2504 ),
2505 )?;
2506 self.stake_credential
2507 .serialize(serializer, force_canonical)?;
2508 serializer.write_bytes_sz(
2509 self.pool.to_raw_bytes(),
2510 self.encodings
2511 .as_ref()
2512 .map(|encs| encs.pool_encoding.clone())
2513 .unwrap_or_default()
2514 .to_str_len_sz(self.pool.to_raw_bytes().len() as u64, force_canonical),
2515 )?;
2516 self.encodings
2517 .as_ref()
2518 .map(|encs| encs.len_encoding)
2519 .unwrap_or_default()
2520 .end(serializer, force_canonical)
2521 }
2522}
2523
2524impl Deserialize for StakeDelegation {
2525 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2526 let len = raw.array_sz()?;
2527 let mut read_len = CBORReadLen::new(len);
2528 read_len.read_elems(3)?;
2529 read_len.finish()?;
2530 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2531 match len {
2532 cbor_event::LenSz::Len(_, _) => (),
2533 cbor_event::LenSz::Indefinite => match raw.special()? {
2534 cbor_event::Special::Break => (),
2535 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2536 },
2537 }
2538 ret
2539 }
2540}
2541
2542impl DeserializeEmbeddedGroup for StakeDelegation {
2543 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2544 raw: &mut Deserializer<R>,
2545 _read_len: &mut CBORReadLen,
2546 len: cbor_event::LenSz,
2547 ) -> Result<Self, DeserializeError> {
2548 let len_encoding = len.into();
2549 (|| -> Result<_, DeserializeError> {
2550 let tag_encoding = (|| -> Result<_, DeserializeError> {
2551 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2552 if tag_value != 2 {
2553 return Err(DeserializeFailure::FixedValueMismatch {
2554 found: Key::Uint(tag_value),
2555 expected: Key::Uint(2),
2556 }
2557 .into());
2558 }
2559 Ok(Some(tag_encoding))
2560 })()
2561 .map_err(|e| e.annotate("tag"))?;
2562 let stake_credential = Credential::deserialize(raw)
2563 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
2564 let (pool, pool_encoding) = raw
2565 .bytes_sz()
2566 .map_err(Into::<DeserializeError>::into)
2567 .and_then(|(bytes, enc)| {
2568 Ed25519KeyHash::from_raw_bytes(&bytes)
2569 .map(|bytes| (bytes, StringEncoding::from(enc)))
2570 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
2571 })
2572 .map_err(|e: DeserializeError| e.annotate("pool"))?;
2573 Ok(StakeDelegation {
2574 stake_credential,
2575 pool,
2576 encodings: Some(StakeDelegationEncoding {
2577 len_encoding,
2578 tag_encoding,
2579 pool_encoding,
2580 }),
2581 })
2582 })()
2583 .map_err(|e| e.annotate("StakeDelegation"))
2584 }
2585}
2586
2587impl Serialize for StakeDeregistration {
2588 fn serialize<'se, W: Write>(
2589 &self,
2590 serializer: &'se mut Serializer<W>,
2591 force_canonical: bool,
2592 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2593 serializer.write_array_sz(
2594 self.encodings
2595 .as_ref()
2596 .map(|encs| encs.len_encoding)
2597 .unwrap_or_default()
2598 .to_len_sz(2, force_canonical),
2599 )?;
2600 self.serialize_as_embedded_group(serializer, force_canonical)
2601 }
2602}
2603
2604impl SerializeEmbeddedGroup for StakeDeregistration {
2605 fn serialize_as_embedded_group<'se, W: Write>(
2606 &self,
2607 serializer: &'se mut Serializer<W>,
2608 force_canonical: bool,
2609 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2610 serializer.write_unsigned_integer_sz(
2611 1u64,
2612 fit_sz(
2613 1u64,
2614 self.encodings
2615 .as_ref()
2616 .map(|encs| encs.tag_encoding)
2617 .unwrap_or_default(),
2618 force_canonical,
2619 ),
2620 )?;
2621 self.stake_credential
2622 .serialize(serializer, force_canonical)?;
2623 self.encodings
2624 .as_ref()
2625 .map(|encs| encs.len_encoding)
2626 .unwrap_or_default()
2627 .end(serializer, force_canonical)
2628 }
2629}
2630
2631impl Deserialize for StakeDeregistration {
2632 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2633 let len = raw.array_sz()?;
2634 let mut read_len = CBORReadLen::new(len);
2635 read_len.read_elems(2)?;
2636 read_len.finish()?;
2637 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2638 match len {
2639 cbor_event::LenSz::Len(_, _) => (),
2640 cbor_event::LenSz::Indefinite => match raw.special()? {
2641 cbor_event::Special::Break => (),
2642 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2643 },
2644 }
2645 ret
2646 }
2647}
2648
2649impl DeserializeEmbeddedGroup for StakeDeregistration {
2650 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2651 raw: &mut Deserializer<R>,
2652 _read_len: &mut CBORReadLen,
2653 len: cbor_event::LenSz,
2654 ) -> Result<Self, DeserializeError> {
2655 let len_encoding = len.into();
2656 (|| -> Result<_, DeserializeError> {
2657 let tag_encoding = (|| -> Result<_, DeserializeError> {
2658 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2659 if tag_value != 1 {
2660 return Err(DeserializeFailure::FixedValueMismatch {
2661 found: Key::Uint(tag_value),
2662 expected: Key::Uint(1),
2663 }
2664 .into());
2665 }
2666 Ok(Some(tag_encoding))
2667 })()
2668 .map_err(|e| e.annotate("tag"))?;
2669 let stake_credential = Credential::deserialize(raw)
2670 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
2671 Ok(StakeDeregistration {
2672 stake_credential,
2673 encodings: Some(StakeDeregistrationEncoding {
2674 len_encoding,
2675 tag_encoding,
2676 }),
2677 })
2678 })()
2679 .map_err(|e| e.annotate("StakeDeregistration"))
2680 }
2681}
2682
2683impl Serialize for StakeRegDelegCert {
2684 fn serialize<'se, W: Write>(
2685 &self,
2686 serializer: &'se mut Serializer<W>,
2687 force_canonical: bool,
2688 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2689 serializer.write_array_sz(
2690 self.encodings
2691 .as_ref()
2692 .map(|encs| encs.len_encoding)
2693 .unwrap_or_default()
2694 .to_len_sz(4, force_canonical),
2695 )?;
2696 self.serialize_as_embedded_group(serializer, force_canonical)
2697 }
2698}
2699
2700impl SerializeEmbeddedGroup for StakeRegDelegCert {
2701 fn serialize_as_embedded_group<'se, W: Write>(
2702 &self,
2703 serializer: &'se mut Serializer<W>,
2704 force_canonical: bool,
2705 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2706 serializer.write_unsigned_integer_sz(
2707 11u64,
2708 fit_sz(
2709 11u64,
2710 self.encodings
2711 .as_ref()
2712 .map(|encs| encs.tag_encoding)
2713 .unwrap_or_default(),
2714 force_canonical,
2715 ),
2716 )?;
2717 self.stake_credential
2718 .serialize(serializer, force_canonical)?;
2719 serializer.write_bytes_sz(
2720 self.pool.to_raw_bytes(),
2721 self.encodings
2722 .as_ref()
2723 .map(|encs| encs.pool_encoding.clone())
2724 .unwrap_or_default()
2725 .to_str_len_sz(self.pool.to_raw_bytes().len() as u64, force_canonical),
2726 )?;
2727 serializer.write_unsigned_integer_sz(
2728 self.deposit,
2729 fit_sz(
2730 self.deposit,
2731 self.encodings
2732 .as_ref()
2733 .map(|encs| encs.deposit_encoding)
2734 .unwrap_or_default(),
2735 force_canonical,
2736 ),
2737 )?;
2738 self.encodings
2739 .as_ref()
2740 .map(|encs| encs.len_encoding)
2741 .unwrap_or_default()
2742 .end(serializer, force_canonical)
2743 }
2744}
2745
2746impl Deserialize for StakeRegDelegCert {
2747 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2748 let len = raw.array_sz()?;
2749 let mut read_len = CBORReadLen::new(len);
2750 read_len.read_elems(4)?;
2751 read_len.finish()?;
2752 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2753 match len {
2754 cbor_event::LenSz::Len(_, _) => (),
2755 cbor_event::LenSz::Indefinite => match raw.special()? {
2756 cbor_event::Special::Break => (),
2757 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2758 },
2759 }
2760 ret
2761 }
2762}
2763
2764impl DeserializeEmbeddedGroup for StakeRegDelegCert {
2765 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2766 raw: &mut Deserializer<R>,
2767 _read_len: &mut CBORReadLen,
2768 len: cbor_event::LenSz,
2769 ) -> Result<Self, DeserializeError> {
2770 let len_encoding = len.into();
2771 (|| -> Result<_, DeserializeError> {
2772 let tag_encoding = (|| -> Result<_, DeserializeError> {
2773 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2774 if tag_value != 11 {
2775 return Err(DeserializeFailure::FixedValueMismatch {
2776 found: Key::Uint(tag_value),
2777 expected: Key::Uint(11),
2778 }
2779 .into());
2780 }
2781 Ok(Some(tag_encoding))
2782 })()
2783 .map_err(|e| e.annotate("tag"))?;
2784 let stake_credential = Credential::deserialize(raw)
2785 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
2786 let (pool, pool_encoding) = raw
2787 .bytes_sz()
2788 .map_err(Into::<DeserializeError>::into)
2789 .and_then(|(bytes, enc)| {
2790 Ed25519KeyHash::from_raw_bytes(&bytes)
2791 .map(|bytes| (bytes, StringEncoding::from(enc)))
2792 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
2793 })
2794 .map_err(|e: DeserializeError| e.annotate("pool"))?;
2795 let (deposit, deposit_encoding) = raw
2796 .unsigned_integer_sz()
2797 .map_err(Into::<DeserializeError>::into)
2798 .map(|(x, enc)| (x, Some(enc)))
2799 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
2800 Ok(StakeRegDelegCert {
2801 stake_credential,
2802 pool,
2803 deposit,
2804 encodings: Some(StakeRegDelegCertEncoding {
2805 len_encoding,
2806 tag_encoding,
2807 pool_encoding,
2808 deposit_encoding,
2809 }),
2810 })
2811 })()
2812 .map_err(|e| e.annotate("StakeRegDelegCert"))
2813 }
2814}
2815
2816impl Serialize for StakeRegistration {
2817 fn serialize<'se, W: Write>(
2818 &self,
2819 serializer: &'se mut Serializer<W>,
2820 force_canonical: bool,
2821 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2822 serializer.write_array_sz(
2823 self.encodings
2824 .as_ref()
2825 .map(|encs| encs.len_encoding)
2826 .unwrap_or_default()
2827 .to_len_sz(2, force_canonical),
2828 )?;
2829 self.serialize_as_embedded_group(serializer, force_canonical)
2830 }
2831}
2832
2833impl SerializeEmbeddedGroup for StakeRegistration {
2834 fn serialize_as_embedded_group<'se, W: Write>(
2835 &self,
2836 serializer: &'se mut Serializer<W>,
2837 force_canonical: bool,
2838 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2839 serializer.write_unsigned_integer_sz(
2840 0u64,
2841 fit_sz(
2842 0u64,
2843 self.encodings
2844 .as_ref()
2845 .map(|encs| encs.tag_encoding)
2846 .unwrap_or_default(),
2847 force_canonical,
2848 ),
2849 )?;
2850 self.stake_credential
2851 .serialize(serializer, force_canonical)?;
2852 self.encodings
2853 .as_ref()
2854 .map(|encs| encs.len_encoding)
2855 .unwrap_or_default()
2856 .end(serializer, force_canonical)
2857 }
2858}
2859
2860impl Deserialize for StakeRegistration {
2861 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2862 let len = raw.array_sz()?;
2863 let mut read_len = CBORReadLen::new(len);
2864 read_len.read_elems(2)?;
2865 read_len.finish()?;
2866 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2867 match len {
2868 cbor_event::LenSz::Len(_, _) => (),
2869 cbor_event::LenSz::Indefinite => match raw.special()? {
2870 cbor_event::Special::Break => (),
2871 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2872 },
2873 }
2874 ret
2875 }
2876}
2877
2878impl DeserializeEmbeddedGroup for StakeRegistration {
2879 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2880 raw: &mut Deserializer<R>,
2881 _read_len: &mut CBORReadLen,
2882 len: cbor_event::LenSz,
2883 ) -> Result<Self, DeserializeError> {
2884 let len_encoding = len.into();
2885 (|| -> Result<_, DeserializeError> {
2886 let tag_encoding = (|| -> Result<_, DeserializeError> {
2887 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2888 if tag_value != 0 {
2889 return Err(DeserializeFailure::FixedValueMismatch {
2890 found: Key::Uint(tag_value),
2891 expected: Key::Uint(0),
2892 }
2893 .into());
2894 }
2895 Ok(Some(tag_encoding))
2896 })()
2897 .map_err(|e| e.annotate("tag"))?;
2898 let stake_credential = Credential::deserialize(raw)
2899 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
2900 Ok(StakeRegistration {
2901 stake_credential,
2902 encodings: Some(StakeRegistrationEncoding {
2903 len_encoding,
2904 tag_encoding,
2905 }),
2906 })
2907 })()
2908 .map_err(|e| e.annotate("StakeRegistration"))
2909 }
2910}
2911
2912impl Serialize for StakeVoteDelegCert {
2913 fn serialize<'se, W: Write>(
2914 &self,
2915 serializer: &'se mut Serializer<W>,
2916 force_canonical: bool,
2917 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2918 serializer.write_array_sz(
2919 self.encodings
2920 .as_ref()
2921 .map(|encs| encs.len_encoding)
2922 .unwrap_or_default()
2923 .to_len_sz(4, force_canonical),
2924 )?;
2925 self.serialize_as_embedded_group(serializer, force_canonical)
2926 }
2927}
2928
2929impl SerializeEmbeddedGroup for StakeVoteDelegCert {
2930 fn serialize_as_embedded_group<'se, W: Write>(
2931 &self,
2932 serializer: &'se mut Serializer<W>,
2933 force_canonical: bool,
2934 ) -> cbor_event::Result<&'se mut Serializer<W>> {
2935 serializer.write_unsigned_integer_sz(
2936 10u64,
2937 fit_sz(
2938 10u64,
2939 self.encodings
2940 .as_ref()
2941 .map(|encs| encs.tag_encoding)
2942 .unwrap_or_default(),
2943 force_canonical,
2944 ),
2945 )?;
2946 self.stake_credential
2947 .serialize(serializer, force_canonical)?;
2948 serializer.write_bytes_sz(
2949 self.pool.to_raw_bytes(),
2950 self.encodings
2951 .as_ref()
2952 .map(|encs| encs.pool_encoding.clone())
2953 .unwrap_or_default()
2954 .to_str_len_sz(self.pool.to_raw_bytes().len() as u64, force_canonical),
2955 )?;
2956 self.d_rep.serialize(serializer, force_canonical)?;
2957 self.encodings
2958 .as_ref()
2959 .map(|encs| encs.len_encoding)
2960 .unwrap_or_default()
2961 .end(serializer, force_canonical)
2962 }
2963}
2964
2965impl Deserialize for StakeVoteDelegCert {
2966 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
2967 let len = raw.array_sz()?;
2968 let mut read_len = CBORReadLen::new(len);
2969 read_len.read_elems(4)?;
2970 read_len.finish()?;
2971 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
2972 match len {
2973 cbor_event::LenSz::Len(_, _) => (),
2974 cbor_event::LenSz::Indefinite => match raw.special()? {
2975 cbor_event::Special::Break => (),
2976 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
2977 },
2978 }
2979 ret
2980 }
2981}
2982
2983impl DeserializeEmbeddedGroup for StakeVoteDelegCert {
2984 fn deserialize_as_embedded_group<R: BufRead + Seek>(
2985 raw: &mut Deserializer<R>,
2986 _read_len: &mut CBORReadLen,
2987 len: cbor_event::LenSz,
2988 ) -> Result<Self, DeserializeError> {
2989 let len_encoding = len.into();
2990 (|| -> Result<_, DeserializeError> {
2991 let tag_encoding = (|| -> Result<_, DeserializeError> {
2992 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
2993 if tag_value != 10 {
2994 return Err(DeserializeFailure::FixedValueMismatch {
2995 found: Key::Uint(tag_value),
2996 expected: Key::Uint(10),
2997 }
2998 .into());
2999 }
3000 Ok(Some(tag_encoding))
3001 })()
3002 .map_err(|e| e.annotate("tag"))?;
3003 let stake_credential = Credential::deserialize(raw)
3004 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
3005 let (pool, pool_encoding) = raw
3006 .bytes_sz()
3007 .map_err(Into::<DeserializeError>::into)
3008 .and_then(|(bytes, enc)| {
3009 Ed25519KeyHash::from_raw_bytes(&bytes)
3010 .map(|bytes| (bytes, StringEncoding::from(enc)))
3011 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
3012 })
3013 .map_err(|e: DeserializeError| e.annotate("pool"))?;
3014 let d_rep =
3015 DRep::deserialize(raw).map_err(|e: DeserializeError| e.annotate("d_rep"))?;
3016 Ok(StakeVoteDelegCert {
3017 stake_credential,
3018 pool,
3019 d_rep,
3020 encodings: Some(StakeVoteDelegCertEncoding {
3021 len_encoding,
3022 tag_encoding,
3023 pool_encoding,
3024 }),
3025 })
3026 })()
3027 .map_err(|e| e.annotate("StakeVoteDelegCert"))
3028 }
3029}
3030
3031impl Serialize for StakeVoteRegDelegCert {
3032 fn serialize<'se, W: Write>(
3033 &self,
3034 serializer: &'se mut Serializer<W>,
3035 force_canonical: bool,
3036 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3037 serializer.write_array_sz(
3038 self.encodings
3039 .as_ref()
3040 .map(|encs| encs.len_encoding)
3041 .unwrap_or_default()
3042 .to_len_sz(5, force_canonical),
3043 )?;
3044 self.serialize_as_embedded_group(serializer, force_canonical)
3045 }
3046}
3047
3048impl SerializeEmbeddedGroup for StakeVoteRegDelegCert {
3049 fn serialize_as_embedded_group<'se, W: Write>(
3050 &self,
3051 serializer: &'se mut Serializer<W>,
3052 force_canonical: bool,
3053 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3054 serializer.write_unsigned_integer_sz(
3055 13u64,
3056 fit_sz(
3057 13u64,
3058 self.encodings
3059 .as_ref()
3060 .map(|encs| encs.tag_encoding)
3061 .unwrap_or_default(),
3062 force_canonical,
3063 ),
3064 )?;
3065 self.stake_credential
3066 .serialize(serializer, force_canonical)?;
3067 serializer.write_bytes_sz(
3068 self.pool.to_raw_bytes(),
3069 self.encodings
3070 .as_ref()
3071 .map(|encs| encs.pool_encoding.clone())
3072 .unwrap_or_default()
3073 .to_str_len_sz(self.pool.to_raw_bytes().len() as u64, force_canonical),
3074 )?;
3075 self.d_rep.serialize(serializer, force_canonical)?;
3076 serializer.write_unsigned_integer_sz(
3077 self.deposit,
3078 fit_sz(
3079 self.deposit,
3080 self.encodings
3081 .as_ref()
3082 .map(|encs| encs.deposit_encoding)
3083 .unwrap_or_default(),
3084 force_canonical,
3085 ),
3086 )?;
3087 self.encodings
3088 .as_ref()
3089 .map(|encs| encs.len_encoding)
3090 .unwrap_or_default()
3091 .end(serializer, force_canonical)
3092 }
3093}
3094
3095impl Deserialize for StakeVoteRegDelegCert {
3096 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3097 let len = raw.array_sz()?;
3098 let mut read_len = CBORReadLen::new(len);
3099 read_len.read_elems(5)?;
3100 read_len.finish()?;
3101 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3102 match len {
3103 cbor_event::LenSz::Len(_, _) => (),
3104 cbor_event::LenSz::Indefinite => match raw.special()? {
3105 cbor_event::Special::Break => (),
3106 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3107 },
3108 }
3109 ret
3110 }
3111}
3112
3113impl DeserializeEmbeddedGroup for StakeVoteRegDelegCert {
3114 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3115 raw: &mut Deserializer<R>,
3116 _read_len: &mut CBORReadLen,
3117 len: cbor_event::LenSz,
3118 ) -> Result<Self, DeserializeError> {
3119 let len_encoding = len.into();
3120 (|| -> Result<_, DeserializeError> {
3121 let tag_encoding = (|| -> Result<_, DeserializeError> {
3122 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
3123 if tag_value != 13 {
3124 return Err(DeserializeFailure::FixedValueMismatch {
3125 found: Key::Uint(tag_value),
3126 expected: Key::Uint(13),
3127 }
3128 .into());
3129 }
3130 Ok(Some(tag_encoding))
3131 })()
3132 .map_err(|e| e.annotate("tag"))?;
3133 let stake_credential = Credential::deserialize(raw)
3134 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
3135 let (pool, pool_encoding) = raw
3136 .bytes_sz()
3137 .map_err(Into::<DeserializeError>::into)
3138 .and_then(|(bytes, enc)| {
3139 Ed25519KeyHash::from_raw_bytes(&bytes)
3140 .map(|bytes| (bytes, StringEncoding::from(enc)))
3141 .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
3142 })
3143 .map_err(|e: DeserializeError| e.annotate("pool"))?;
3144 let d_rep =
3145 DRep::deserialize(raw).map_err(|e: DeserializeError| e.annotate("d_rep"))?;
3146 let (deposit, deposit_encoding) = raw
3147 .unsigned_integer_sz()
3148 .map_err(Into::<DeserializeError>::into)
3149 .map(|(x, enc)| (x, Some(enc)))
3150 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
3151 Ok(StakeVoteRegDelegCert {
3152 stake_credential,
3153 pool,
3154 d_rep,
3155 deposit,
3156 encodings: Some(StakeVoteRegDelegCertEncoding {
3157 len_encoding,
3158 tag_encoding,
3159 pool_encoding,
3160 deposit_encoding,
3161 }),
3162 })
3163 })()
3164 .map_err(|e| e.annotate("StakeVoteRegDelegCert"))
3165 }
3166}
3167
3168impl Serialize for UnregCert {
3169 fn serialize<'se, W: Write>(
3170 &self,
3171 serializer: &'se mut Serializer<W>,
3172 force_canonical: bool,
3173 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3174 serializer.write_array_sz(
3175 self.encodings
3176 .as_ref()
3177 .map(|encs| encs.len_encoding)
3178 .unwrap_or_default()
3179 .to_len_sz(3, force_canonical),
3180 )?;
3181 self.serialize_as_embedded_group(serializer, force_canonical)
3182 }
3183}
3184
3185impl SerializeEmbeddedGroup for UnregCert {
3186 fn serialize_as_embedded_group<'se, W: Write>(
3187 &self,
3188 serializer: &'se mut Serializer<W>,
3189 force_canonical: bool,
3190 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3191 serializer.write_unsigned_integer_sz(
3192 8u64,
3193 fit_sz(
3194 8u64,
3195 self.encodings
3196 .as_ref()
3197 .map(|encs| encs.tag_encoding)
3198 .unwrap_or_default(),
3199 force_canonical,
3200 ),
3201 )?;
3202 self.stake_credential
3203 .serialize(serializer, force_canonical)?;
3204 serializer.write_unsigned_integer_sz(
3205 self.deposit,
3206 fit_sz(
3207 self.deposit,
3208 self.encodings
3209 .as_ref()
3210 .map(|encs| encs.deposit_encoding)
3211 .unwrap_or_default(),
3212 force_canonical,
3213 ),
3214 )?;
3215 self.encodings
3216 .as_ref()
3217 .map(|encs| encs.len_encoding)
3218 .unwrap_or_default()
3219 .end(serializer, force_canonical)
3220 }
3221}
3222
3223impl Deserialize for UnregCert {
3224 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3225 let len = raw.array_sz()?;
3226 let mut read_len = CBORReadLen::new(len);
3227 read_len.read_elems(3)?;
3228 read_len.finish()?;
3229 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3230 match len {
3231 cbor_event::LenSz::Len(_, _) => (),
3232 cbor_event::LenSz::Indefinite => match raw.special()? {
3233 cbor_event::Special::Break => (),
3234 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3235 },
3236 }
3237 ret
3238 }
3239}
3240
3241impl DeserializeEmbeddedGroup for UnregCert {
3242 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3243 raw: &mut Deserializer<R>,
3244 _read_len: &mut CBORReadLen,
3245 len: cbor_event::LenSz,
3246 ) -> Result<Self, DeserializeError> {
3247 let len_encoding = len.into();
3248 (|| -> Result<_, DeserializeError> {
3249 let tag_encoding = (|| -> Result<_, DeserializeError> {
3250 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
3251 if tag_value != 8 {
3252 return Err(DeserializeFailure::FixedValueMismatch {
3253 found: Key::Uint(tag_value),
3254 expected: Key::Uint(8),
3255 }
3256 .into());
3257 }
3258 Ok(Some(tag_encoding))
3259 })()
3260 .map_err(|e| e.annotate("tag"))?;
3261 let stake_credential = Credential::deserialize(raw)
3262 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
3263 let (deposit, deposit_encoding) = raw
3264 .unsigned_integer_sz()
3265 .map_err(Into::<DeserializeError>::into)
3266 .map(|(x, enc)| (x, Some(enc)))
3267 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
3268 Ok(UnregCert {
3269 stake_credential,
3270 deposit,
3271 encodings: Some(UnregCertEncoding {
3272 len_encoding,
3273 tag_encoding,
3274 deposit_encoding,
3275 }),
3276 })
3277 })()
3278 .map_err(|e| e.annotate("UnregCert"))
3279 }
3280}
3281
3282impl Serialize for UnregDrepCert {
3283 fn serialize<'se, W: Write>(
3284 &self,
3285 serializer: &'se mut Serializer<W>,
3286 force_canonical: bool,
3287 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3288 serializer.write_array_sz(
3289 self.encodings
3290 .as_ref()
3291 .map(|encs| encs.len_encoding)
3292 .unwrap_or_default()
3293 .to_len_sz(3, force_canonical),
3294 )?;
3295 self.serialize_as_embedded_group(serializer, force_canonical)
3296 }
3297}
3298
3299impl SerializeEmbeddedGroup for UnregDrepCert {
3300 fn serialize_as_embedded_group<'se, W: Write>(
3301 &self,
3302 serializer: &'se mut Serializer<W>,
3303 force_canonical: bool,
3304 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3305 serializer.write_unsigned_integer_sz(
3306 17u64,
3307 fit_sz(
3308 17u64,
3309 self.encodings
3310 .as_ref()
3311 .map(|encs| encs.index_0_encoding)
3312 .unwrap_or_default(),
3313 force_canonical,
3314 ),
3315 )?;
3316 self.drep_credential
3317 .serialize(serializer, force_canonical)?;
3318 serializer.write_unsigned_integer_sz(
3319 self.deposit,
3320 fit_sz(
3321 self.deposit,
3322 self.encodings
3323 .as_ref()
3324 .map(|encs| encs.deposit_encoding)
3325 .unwrap_or_default(),
3326 force_canonical,
3327 ),
3328 )?;
3329 self.encodings
3330 .as_ref()
3331 .map(|encs| encs.len_encoding)
3332 .unwrap_or_default()
3333 .end(serializer, force_canonical)
3334 }
3335}
3336
3337impl Deserialize for UnregDrepCert {
3338 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3339 let len = raw.array_sz()?;
3340 let mut read_len = CBORReadLen::new(len);
3341 read_len.read_elems(3)?;
3342 read_len.finish()?;
3343 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3344 match len {
3345 cbor_event::LenSz::Len(_, _) => (),
3346 cbor_event::LenSz::Indefinite => match raw.special()? {
3347 cbor_event::Special::Break => (),
3348 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3349 },
3350 }
3351 ret
3352 }
3353}
3354
3355impl DeserializeEmbeddedGroup for UnregDrepCert {
3356 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3357 raw: &mut Deserializer<R>,
3358 _read_len: &mut CBORReadLen,
3359 len: cbor_event::LenSz,
3360 ) -> Result<Self, DeserializeError> {
3361 let len_encoding = len.into();
3362 (|| -> Result<_, DeserializeError> {
3363 let index_0_encoding = (|| -> Result<_, DeserializeError> {
3364 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
3365 if index_0_value != 17 {
3366 return Err(DeserializeFailure::FixedValueMismatch {
3367 found: Key::Uint(index_0_value),
3368 expected: Key::Uint(17),
3369 }
3370 .into());
3371 }
3372 Ok(Some(index_0_encoding))
3373 })()
3374 .map_err(|e| e.annotate("index_0"))?;
3375 let drep_credential = Credential::deserialize(raw)
3376 .map_err(|e: DeserializeError| e.annotate("drep_credential"))?;
3377 let (deposit, deposit_encoding) = raw
3378 .unsigned_integer_sz()
3379 .map_err(Into::<DeserializeError>::into)
3380 .map(|(x, enc)| (x, Some(enc)))
3381 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
3382 Ok(UnregDrepCert {
3383 drep_credential,
3384 deposit,
3385 encodings: Some(UnregDrepCertEncoding {
3386 len_encoding,
3387 index_0_encoding,
3388 deposit_encoding,
3389 }),
3390 })
3391 })()
3392 .map_err(|e| e.annotate("UnregDrepCert"))
3393 }
3394}
3395
3396impl Serialize for UpdateDrepCert {
3397 fn serialize<'se, W: Write>(
3398 &self,
3399 serializer: &'se mut Serializer<W>,
3400 force_canonical: bool,
3401 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3402 serializer.write_array_sz(
3403 self.encodings
3404 .as_ref()
3405 .map(|encs| encs.len_encoding)
3406 .unwrap_or_default()
3407 .to_len_sz(3, force_canonical),
3408 )?;
3409 self.serialize_as_embedded_group(serializer, force_canonical)
3410 }
3411}
3412
3413impl SerializeEmbeddedGroup for UpdateDrepCert {
3414 fn serialize_as_embedded_group<'se, W: Write>(
3415 &self,
3416 serializer: &'se mut Serializer<W>,
3417 force_canonical: bool,
3418 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3419 serializer.write_unsigned_integer_sz(
3420 18u64,
3421 fit_sz(
3422 18u64,
3423 self.encodings
3424 .as_ref()
3425 .map(|encs| encs.index_0_encoding)
3426 .unwrap_or_default(),
3427 force_canonical,
3428 ),
3429 )?;
3430 self.drep_credential
3431 .serialize(serializer, force_canonical)?;
3432 match &self.anchor {
3433 Some(x) => x.serialize(serializer, force_canonical),
3434 None => serializer.write_special(cbor_event::Special::Null),
3435 }?;
3436 self.encodings
3437 .as_ref()
3438 .map(|encs| encs.len_encoding)
3439 .unwrap_or_default()
3440 .end(serializer, force_canonical)
3441 }
3442}
3443
3444impl Deserialize for UpdateDrepCert {
3445 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3446 let len = raw.array_sz()?;
3447 let mut read_len = CBORReadLen::new(len);
3448 read_len.read_elems(3)?;
3449 read_len.finish()?;
3450 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3451 match len {
3452 cbor_event::LenSz::Len(_, _) => (),
3453 cbor_event::LenSz::Indefinite => match raw.special()? {
3454 cbor_event::Special::Break => (),
3455 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3456 },
3457 }
3458 ret
3459 }
3460}
3461
3462impl DeserializeEmbeddedGroup for UpdateDrepCert {
3463 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3464 raw: &mut Deserializer<R>,
3465 _read_len: &mut CBORReadLen,
3466 len: cbor_event::LenSz,
3467 ) -> Result<Self, DeserializeError> {
3468 let len_encoding = len.into();
3469 (|| -> Result<_, DeserializeError> {
3470 let index_0_encoding = (|| -> Result<_, DeserializeError> {
3471 let (index_0_value, index_0_encoding) = raw.unsigned_integer_sz()?;
3472 if index_0_value != 18 {
3473 return Err(DeserializeFailure::FixedValueMismatch {
3474 found: Key::Uint(index_0_value),
3475 expected: Key::Uint(18),
3476 }
3477 .into());
3478 }
3479 Ok(Some(index_0_encoding))
3480 })()
3481 .map_err(|e| e.annotate("index_0"))?;
3482 let drep_credential = Credential::deserialize(raw)
3483 .map_err(|e: DeserializeError| e.annotate("drep_credential"))?;
3484 let anchor = (|| -> Result<_, DeserializeError> {
3485 Ok(match raw.cbor_type()? != cbor_event::Type::Special {
3486 true => Some(Anchor::deserialize(raw)?),
3487 false => {
3488 if raw.special()? != cbor_event::Special::Null {
3489 return Err(DeserializeFailure::ExpectedNull.into());
3490 }
3491 None
3492 }
3493 })
3494 })()
3495 .map_err(|e| e.annotate("anchor"))?;
3496 Ok(UpdateDrepCert {
3497 drep_credential,
3498 anchor,
3499 encodings: Some(UpdateDrepCertEncoding {
3500 len_encoding,
3501 index_0_encoding,
3502 }),
3503 })
3504 })()
3505 .map_err(|e| e.annotate("UpdateDrepCert"))
3506 }
3507}
3508
3509impl Serialize for Url {
3510 fn serialize<'se, W: Write>(
3511 &self,
3512 serializer: &'se mut Serializer<W>,
3513 force_canonical: bool,
3514 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3515 serializer.write_text_sz(
3516 &self.inner,
3517 self.encodings
3518 .as_ref()
3519 .map(|encs| encs.inner_encoding.clone())
3520 .unwrap_or_default()
3521 .to_str_len_sz(self.inner.len() as u64, force_canonical),
3522 )
3523 }
3524}
3525
3526impl Deserialize for Url {
3527 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3528 let (inner, inner_encoding) = raw
3529 .text_sz()
3530 .map(|(s, enc)| (s, StringEncoding::from(enc)))?;
3531 if inner.len() > 128 {
3532 return Err(DeserializeError::new(
3533 "Url",
3534 DeserializeFailure::RangeCheck {
3535 found: inner.len() as isize,
3536 min: Some(0),
3537 max: Some(128),
3538 },
3539 ));
3540 }
3541 Ok(Self {
3542 inner,
3543 encodings: Some(UrlEncoding { inner_encoding }),
3544 })
3545 }
3546}
3547
3548impl Serialize for VoteDelegCert {
3549 fn serialize<'se, W: Write>(
3550 &self,
3551 serializer: &'se mut Serializer<W>,
3552 force_canonical: bool,
3553 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3554 serializer.write_array_sz(
3555 self.encodings
3556 .as_ref()
3557 .map(|encs| encs.len_encoding)
3558 .unwrap_or_default()
3559 .to_len_sz(3, force_canonical),
3560 )?;
3561 self.serialize_as_embedded_group(serializer, force_canonical)
3562 }
3563}
3564
3565impl SerializeEmbeddedGroup for VoteDelegCert {
3566 fn serialize_as_embedded_group<'se, W: Write>(
3567 &self,
3568 serializer: &'se mut Serializer<W>,
3569 force_canonical: bool,
3570 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3571 serializer.write_unsigned_integer_sz(
3572 9u64,
3573 fit_sz(
3574 9u64,
3575 self.encodings
3576 .as_ref()
3577 .map(|encs| encs.tag_encoding)
3578 .unwrap_or_default(),
3579 force_canonical,
3580 ),
3581 )?;
3582 self.stake_credential
3583 .serialize(serializer, force_canonical)?;
3584 self.d_rep.serialize(serializer, force_canonical)?;
3585 self.encodings
3586 .as_ref()
3587 .map(|encs| encs.len_encoding)
3588 .unwrap_or_default()
3589 .end(serializer, force_canonical)
3590 }
3591}
3592
3593impl Deserialize for VoteDelegCert {
3594 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3595 let len = raw.array_sz()?;
3596 let mut read_len = CBORReadLen::new(len);
3597 read_len.read_elems(3)?;
3598 read_len.finish()?;
3599 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3600 match len {
3601 cbor_event::LenSz::Len(_, _) => (),
3602 cbor_event::LenSz::Indefinite => match raw.special()? {
3603 cbor_event::Special::Break => (),
3604 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3605 },
3606 }
3607 ret
3608 }
3609}
3610
3611impl DeserializeEmbeddedGroup for VoteDelegCert {
3612 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3613 raw: &mut Deserializer<R>,
3614 _read_len: &mut CBORReadLen,
3615 len: cbor_event::LenSz,
3616 ) -> Result<Self, DeserializeError> {
3617 let len_encoding = len.into();
3618 (|| -> Result<_, DeserializeError> {
3619 let tag_encoding = (|| -> Result<_, DeserializeError> {
3620 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
3621 if tag_value != 9 {
3622 return Err(DeserializeFailure::FixedValueMismatch {
3623 found: Key::Uint(tag_value),
3624 expected: Key::Uint(9),
3625 }
3626 .into());
3627 }
3628 Ok(Some(tag_encoding))
3629 })()
3630 .map_err(|e| e.annotate("tag"))?;
3631 let stake_credential = Credential::deserialize(raw)
3632 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
3633 let d_rep =
3634 DRep::deserialize(raw).map_err(|e: DeserializeError| e.annotate("d_rep"))?;
3635 Ok(VoteDelegCert {
3636 stake_credential,
3637 d_rep,
3638 encodings: Some(VoteDelegCertEncoding {
3639 len_encoding,
3640 tag_encoding,
3641 }),
3642 })
3643 })()
3644 .map_err(|e| e.annotate("VoteDelegCert"))
3645 }
3646}
3647
3648impl Serialize for VoteRegDelegCert {
3649 fn serialize<'se, W: Write>(
3650 &self,
3651 serializer: &'se mut Serializer<W>,
3652 force_canonical: bool,
3653 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3654 serializer.write_array_sz(
3655 self.encodings
3656 .as_ref()
3657 .map(|encs| encs.len_encoding)
3658 .unwrap_or_default()
3659 .to_len_sz(4, force_canonical),
3660 )?;
3661 self.serialize_as_embedded_group(serializer, force_canonical)
3662 }
3663}
3664
3665impl SerializeEmbeddedGroup for VoteRegDelegCert {
3666 fn serialize_as_embedded_group<'se, W: Write>(
3667 &self,
3668 serializer: &'se mut Serializer<W>,
3669 force_canonical: bool,
3670 ) -> cbor_event::Result<&'se mut Serializer<W>> {
3671 serializer.write_unsigned_integer_sz(
3672 12u64,
3673 fit_sz(
3674 12u64,
3675 self.encodings
3676 .as_ref()
3677 .map(|encs| encs.tag_encoding)
3678 .unwrap_or_default(),
3679 force_canonical,
3680 ),
3681 )?;
3682 self.stake_credential
3683 .serialize(serializer, force_canonical)?;
3684 self.d_rep.serialize(serializer, force_canonical)?;
3685 serializer.write_unsigned_integer_sz(
3686 self.deposit,
3687 fit_sz(
3688 self.deposit,
3689 self.encodings
3690 .as_ref()
3691 .map(|encs| encs.deposit_encoding)
3692 .unwrap_or_default(),
3693 force_canonical,
3694 ),
3695 )?;
3696 self.encodings
3697 .as_ref()
3698 .map(|encs| encs.len_encoding)
3699 .unwrap_or_default()
3700 .end(serializer, force_canonical)
3701 }
3702}
3703
3704impl Deserialize for VoteRegDelegCert {
3705 fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
3706 let len = raw.array_sz()?;
3707 let mut read_len = CBORReadLen::new(len);
3708 read_len.read_elems(4)?;
3709 read_len.finish()?;
3710 let ret = Self::deserialize_as_embedded_group(raw, &mut read_len, len);
3711 match len {
3712 cbor_event::LenSz::Len(_, _) => (),
3713 cbor_event::LenSz::Indefinite => match raw.special()? {
3714 cbor_event::Special::Break => (),
3715 _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
3716 },
3717 }
3718 ret
3719 }
3720}
3721
3722impl DeserializeEmbeddedGroup for VoteRegDelegCert {
3723 fn deserialize_as_embedded_group<R: BufRead + Seek>(
3724 raw: &mut Deserializer<R>,
3725 _read_len: &mut CBORReadLen,
3726 len: cbor_event::LenSz,
3727 ) -> Result<Self, DeserializeError> {
3728 let len_encoding = len.into();
3729 (|| -> Result<_, DeserializeError> {
3730 let tag_encoding = (|| -> Result<_, DeserializeError> {
3731 let (tag_value, tag_encoding) = raw.unsigned_integer_sz()?;
3732 if tag_value != 12 {
3733 return Err(DeserializeFailure::FixedValueMismatch {
3734 found: Key::Uint(tag_value),
3735 expected: Key::Uint(12),
3736 }
3737 .into());
3738 }
3739 Ok(Some(tag_encoding))
3740 })()
3741 .map_err(|e| e.annotate("tag"))?;
3742 let stake_credential = Credential::deserialize(raw)
3743 .map_err(|e: DeserializeError| e.annotate("stake_credential"))?;
3744 let d_rep =
3745 DRep::deserialize(raw).map_err(|e: DeserializeError| e.annotate("d_rep"))?;
3746 let (deposit, deposit_encoding) = raw
3747 .unsigned_integer_sz()
3748 .map_err(Into::<DeserializeError>::into)
3749 .map(|(x, enc)| (x, Some(enc)))
3750 .map_err(|e: DeserializeError| e.annotate("deposit"))?;
3751 Ok(VoteRegDelegCert {
3752 stake_credential,
3753 d_rep,
3754 deposit,
3755 encodings: Some(VoteRegDelegCertEncoding {
3756 len_encoding,
3757 tag_encoding,
3758 deposit_encoding,
3759 }),
3760 })
3761 })()
3762 .map_err(|e| e.annotate("VoteRegDelegCert"))
3763 }
3764}