cml_multi_era/byron/update/
serialization.rs

1// This file was code-generated using an experimental CDDL to rust tool:
2// https://github.com/dcSpark/cddl-codegen
3
4use crate::byron::ByronAny;
5
6use super::*;
7use cbor_event;
8use cbor_event::de::Deserializer;
9use cbor_event::se::Serializer;
10use cml_chain::utils::BigInteger;
11use cml_core::error::*;
12use cml_core::serialization::*;
13use cml_crypto::RawBytesEncoding;
14use std::io::{BufRead, Seek, Write};
15
16impl cbor_event::se::Serialize for Bvermod {
17    fn serialize<'se, W: Write>(
18        &self,
19        serializer: &'se mut Serializer<W>,
20    ) -> cbor_event::Result<&'se mut Serializer<W>> {
21        serializer.write_array(cbor_event::Len::Len(14))?;
22        serializer.write_array(cbor_event::Len::Len(self.script_version.len() as u64))?;
23        for element in self.script_version.iter() {
24            serializer.write_unsigned_integer(*element as u64)?;
25        }
26        serializer.write_array(cbor_event::Len::Len(self.slot_duration.len() as u64))?;
27        for element in self.slot_duration.iter() {
28            // hand-edit to use cml's Serialize
29            cml_core::serialization::Serialize::serialize(element, serializer, true)?;
30        }
31        serializer.write_array(cbor_event::Len::Len(self.max_block_size.len() as u64))?;
32        for element in self.max_block_size.iter() {
33            // hand-edit to use cml's Serialize
34            cml_core::serialization::Serialize::serialize(element, serializer, true)?;
35        }
36        serializer.write_array(cbor_event::Len::Len(self.max_header_size.len() as u64))?;
37        for element in self.max_header_size.iter() {
38            // hand-edit to use cml's Serialize
39            cml_core::serialization::Serialize::serialize(element, serializer, true)?;
40        }
41        serializer.write_array(cbor_event::Len::Len(self.max_tx_size.len() as u64))?;
42        for element in self.max_tx_size.iter() {
43            // hand-edit to use cml's Serialize
44            cml_core::serialization::Serialize::serialize(element, serializer, true)?;
45        }
46        serializer.write_array(cbor_event::Len::Len(self.max_proposal_size.len() as u64))?;
47        for element in self.max_proposal_size.iter() {
48            // hand-edit to use cml's Serialize
49            cml_core::serialization::Serialize::serialize(element, serializer, true)?;
50        }
51        serializer.write_array(cbor_event::Len::Len(self.mpc_thd.len() as u64))?;
52        for element in self.mpc_thd.iter() {
53            serializer.write_unsigned_integer(*element)?;
54        }
55        serializer.write_array(cbor_event::Len::Len(self.heavy_del_thd.len() as u64))?;
56        for element in self.heavy_del_thd.iter() {
57            serializer.write_unsigned_integer(*element)?;
58        }
59        serializer.write_array(cbor_event::Len::Len(self.update_vote_thd.len() as u64))?;
60        for element in self.update_vote_thd.iter() {
61            serializer.write_unsigned_integer(*element)?;
62        }
63        serializer.write_array(cbor_event::Len::Len(self.update_proposal_thd.len() as u64))?;
64        for element in self.update_proposal_thd.iter() {
65            serializer.write_unsigned_integer(*element)?;
66        }
67        serializer.write_array(cbor_event::Len::Len(self.update_implicit.len() as u64))?;
68        for element in self.update_implicit.iter() {
69            serializer.write_unsigned_integer(*element)?;
70        }
71        serializer.write_array(cbor_event::Len::Len(self.soft_fork_rule.len() as u64))?;
72        for element in self.soft_fork_rule.iter() {
73            element.serialize(serializer)?;
74        }
75        serializer.write_array(cbor_event::Len::Len(self.tx_fee_policy.len() as u64))?;
76        for element in self.tx_fee_policy.iter() {
77            element.serialize(serializer)?;
78        }
79        serializer.write_array(cbor_event::Len::Len(self.unlock_stake_epoch.len() as u64))?;
80        for element in self.unlock_stake_epoch.iter() {
81            serializer.write_unsigned_integer(*element)?;
82        }
83        Ok(serializer)
84    }
85}
86
87impl Deserialize for Bvermod {
88    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
89        let len = raw.array()?;
90        let mut read_len = CBORReadLen::from(len);
91        read_len.read_elems(14)?;
92        read_len.finish()?;
93        (|| -> Result<_, DeserializeError> {
94            let script_version = (|| -> Result<_, DeserializeError> {
95                let mut script_version_arr = Vec::new();
96                let len = raw.array()?;
97                while match len {
98                    cbor_event::Len::Len(n) => (script_version_arr.len() as u64) < n,
99                    cbor_event::Len::Indefinite => true,
100                } {
101                    if raw.cbor_type()? == cbor_event::Type::Special {
102                        assert_eq!(raw.special()?, cbor_event::Special::Break);
103                        break;
104                    }
105                    script_version_arr.push(raw.unsigned_integer()? as u16);
106                }
107                Ok(script_version_arr)
108            })()
109            .map_err(|e| e.annotate("script_version"))?;
110            let slot_duration = (|| -> Result<_, DeserializeError> {
111                let mut slot_duration_arr = Vec::new();
112                let len = raw.array()?;
113                while match len {
114                    cbor_event::Len::Len(n) => (slot_duration_arr.len() as u64) < n,
115                    cbor_event::Len::Indefinite => true,
116                } {
117                    if raw.cbor_type()? == cbor_event::Type::Special {
118                        assert_eq!(raw.special()?, cbor_event::Special::Break);
119                        break;
120                    }
121                    slot_duration_arr.push(BigInteger::deserialize(raw)?);
122                }
123                Ok(slot_duration_arr)
124            })()
125            .map_err(|e| e.annotate("slot_duration"))?;
126            let max_block_size = (|| -> Result<_, DeserializeError> {
127                let mut max_block_size_arr = Vec::new();
128                let len = raw.array()?;
129                while match len {
130                    cbor_event::Len::Len(n) => (max_block_size_arr.len() as u64) < n,
131                    cbor_event::Len::Indefinite => true,
132                } {
133                    if raw.cbor_type()? == cbor_event::Type::Special {
134                        assert_eq!(raw.special()?, cbor_event::Special::Break);
135                        break;
136                    }
137                    max_block_size_arr.push(BigInteger::deserialize(raw)?);
138                }
139                Ok(max_block_size_arr)
140            })()
141            .map_err(|e| e.annotate("max_block_size"))?;
142            let max_header_size = (|| -> Result<_, DeserializeError> {
143                let mut max_header_size_arr = Vec::new();
144                let len = raw.array()?;
145                while match len {
146                    cbor_event::Len::Len(n) => (max_header_size_arr.len() as u64) < n,
147                    cbor_event::Len::Indefinite => true,
148                } {
149                    if raw.cbor_type()? == cbor_event::Type::Special {
150                        assert_eq!(raw.special()?, cbor_event::Special::Break);
151                        break;
152                    }
153                    max_header_size_arr.push(BigInteger::deserialize(raw)?);
154                }
155                Ok(max_header_size_arr)
156            })()
157            .map_err(|e| e.annotate("max_header_size"))?;
158            let max_tx_size = (|| -> Result<_, DeserializeError> {
159                let mut max_tx_size_arr = Vec::new();
160                let len = raw.array()?;
161                while match len {
162                    cbor_event::Len::Len(n) => (max_tx_size_arr.len() as u64) < n,
163                    cbor_event::Len::Indefinite => true,
164                } {
165                    if raw.cbor_type()? == cbor_event::Type::Special {
166                        assert_eq!(raw.special()?, cbor_event::Special::Break);
167                        break;
168                    }
169                    max_tx_size_arr.push(BigInteger::deserialize(raw)?);
170                }
171                Ok(max_tx_size_arr)
172            })()
173            .map_err(|e| e.annotate("max_tx_size"))?;
174            let max_proposal_size = (|| -> Result<_, DeserializeError> {
175                let mut max_proposal_size_arr = Vec::new();
176                let len = raw.array()?;
177                while match len {
178                    cbor_event::Len::Len(n) => (max_proposal_size_arr.len() as u64) < n,
179                    cbor_event::Len::Indefinite => true,
180                } {
181                    if raw.cbor_type()? == cbor_event::Type::Special {
182                        assert_eq!(raw.special()?, cbor_event::Special::Break);
183                        break;
184                    }
185                    max_proposal_size_arr.push(BigInteger::deserialize(raw)?);
186                }
187                Ok(max_proposal_size_arr)
188            })()
189            .map_err(|e| e.annotate("max_proposal_size"))?;
190            let mpc_thd = (|| -> Result<_, DeserializeError> {
191                let mut mpc_thd_arr = Vec::new();
192                let len = raw.array()?;
193                while match len {
194                    cbor_event::Len::Len(n) => (mpc_thd_arr.len() as u64) < n,
195                    cbor_event::Len::Indefinite => true,
196                } {
197                    if raw.cbor_type()? == cbor_event::Type::Special {
198                        assert_eq!(raw.special()?, cbor_event::Special::Break);
199                        break;
200                    }
201                    mpc_thd_arr.push(raw.unsigned_integer()?);
202                }
203                Ok(mpc_thd_arr)
204            })()
205            .map_err(|e| e.annotate("mpc_thd"))?;
206            let heavy_del_thd = (|| -> Result<_, DeserializeError> {
207                let mut heavy_del_thd_arr = Vec::new();
208                let len = raw.array()?;
209                while match len {
210                    cbor_event::Len::Len(n) => (heavy_del_thd_arr.len() as u64) < n,
211                    cbor_event::Len::Indefinite => true,
212                } {
213                    if raw.cbor_type()? == cbor_event::Type::Special {
214                        assert_eq!(raw.special()?, cbor_event::Special::Break);
215                        break;
216                    }
217                    heavy_del_thd_arr.push(raw.unsigned_integer()?);
218                }
219                Ok(heavy_del_thd_arr)
220            })()
221            .map_err(|e| e.annotate("heavy_del_thd"))?;
222            let update_vote_thd = (|| -> Result<_, DeserializeError> {
223                let mut update_vote_thd_arr = Vec::new();
224                let len = raw.array()?;
225                while match len {
226                    cbor_event::Len::Len(n) => (update_vote_thd_arr.len() as u64) < n,
227                    cbor_event::Len::Indefinite => true,
228                } {
229                    if raw.cbor_type()? == cbor_event::Type::Special {
230                        assert_eq!(raw.special()?, cbor_event::Special::Break);
231                        break;
232                    }
233                    update_vote_thd_arr.push(raw.unsigned_integer()?);
234                }
235                Ok(update_vote_thd_arr)
236            })()
237            .map_err(|e| e.annotate("update_vote_thd"))?;
238            let update_proposal_thd = (|| -> Result<_, DeserializeError> {
239                let mut update_proposal_thd_arr = Vec::new();
240                let len = raw.array()?;
241                while match len {
242                    cbor_event::Len::Len(n) => (update_proposal_thd_arr.len() as u64) < n,
243                    cbor_event::Len::Indefinite => true,
244                } {
245                    if raw.cbor_type()? == cbor_event::Type::Special {
246                        assert_eq!(raw.special()?, cbor_event::Special::Break);
247                        break;
248                    }
249                    update_proposal_thd_arr.push(raw.unsigned_integer()?);
250                }
251                Ok(update_proposal_thd_arr)
252            })()
253            .map_err(|e| e.annotate("update_proposal_thd"))?;
254            let update_implicit = (|| -> Result<_, DeserializeError> {
255                let mut update_implicit_arr = Vec::new();
256                let len = raw.array()?;
257                while match len {
258                    cbor_event::Len::Len(n) => (update_implicit_arr.len() as u64) < n,
259                    cbor_event::Len::Indefinite => true,
260                } {
261                    if raw.cbor_type()? == cbor_event::Type::Special {
262                        assert_eq!(raw.special()?, cbor_event::Special::Break);
263                        break;
264                    }
265                    update_implicit_arr.push(raw.unsigned_integer()?);
266                }
267                Ok(update_implicit_arr)
268            })()
269            .map_err(|e| e.annotate("update_implicit"))?;
270            let soft_fork_rule = (|| -> Result<_, DeserializeError> {
271                let mut soft_fork_rule_arr = Vec::new();
272                let len = raw.array()?;
273                while match len {
274                    cbor_event::Len::Len(n) => (soft_fork_rule_arr.len() as u64) < n,
275                    cbor_event::Len::Indefinite => true,
276                } {
277                    if raw.cbor_type()? == cbor_event::Type::Special {
278                        assert_eq!(raw.special()?, cbor_event::Special::Break);
279                        break;
280                    }
281                    soft_fork_rule_arr.push(SoftForkRule::deserialize(raw)?);
282                }
283                Ok(soft_fork_rule_arr)
284            })()
285            .map_err(|e| e.annotate("soft_fork_rule"))?;
286            let tx_fee_policy = (|| -> Result<_, DeserializeError> {
287                let mut tx_fee_policy_arr = Vec::new();
288                let len = raw.array()?;
289                while match len {
290                    cbor_event::Len::Len(n) => (tx_fee_policy_arr.len() as u64) < n,
291                    cbor_event::Len::Indefinite => true,
292                } {
293                    if raw.cbor_type()? == cbor_event::Type::Special {
294                        assert_eq!(raw.special()?, cbor_event::Special::Break);
295                        break;
296                    }
297                    tx_fee_policy_arr.push(ByronTxFeePolicy::deserialize(raw)?);
298                }
299                Ok(tx_fee_policy_arr)
300            })()
301            .map_err(|e| e.annotate("tx_fee_policy"))?;
302            let unlock_stake_epoch = (|| -> Result<_, DeserializeError> {
303                let mut unlock_stake_epoch_arr = Vec::new();
304                let len = raw.array()?;
305                while match len {
306                    cbor_event::Len::Len(n) => (unlock_stake_epoch_arr.len() as u64) < n,
307                    cbor_event::Len::Indefinite => true,
308                } {
309                    if raw.cbor_type()? == cbor_event::Type::Special {
310                        assert_eq!(raw.special()?, cbor_event::Special::Break);
311                        break;
312                    }
313                    unlock_stake_epoch_arr.push(raw.unsigned_integer()?);
314                }
315                Ok(unlock_stake_epoch_arr)
316            })()
317            .map_err(|e| e.annotate("unlock_stake_epoch"))?;
318            match len {
319                cbor_event::Len::Len(_) => (),
320                cbor_event::Len::Indefinite => match raw.special()? {
321                    cbor_event::Special::Break => (),
322                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
323                },
324            }
325            Ok(Bvermod {
326                script_version,
327                slot_duration,
328                max_block_size,
329                max_header_size,
330                max_tx_size,
331                max_proposal_size,
332                mpc_thd,
333                heavy_del_thd,
334                update_vote_thd,
335                update_proposal_thd,
336                update_implicit,
337                soft_fork_rule,
338                tx_fee_policy,
339                unlock_stake_epoch,
340            })
341        })()
342        .map_err(|e| e.annotate("Bvermod"))
343    }
344}
345
346impl cbor_event::se::Serialize for ByronBlockVersion {
347    fn serialize<'se, W: Write>(
348        &self,
349        serializer: &'se mut Serializer<W>,
350    ) -> cbor_event::Result<&'se mut Serializer<W>> {
351        serializer.write_array(cbor_event::Len::Len(3))?;
352        serializer.write_unsigned_integer(self.u16 as u64)?;
353        serializer.write_unsigned_integer(self.u162 as u64)?;
354        serializer.write_unsigned_integer(self.u8 as u64)?;
355        Ok(serializer)
356    }
357}
358
359impl Deserialize for ByronBlockVersion {
360    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
361        let len = raw.array()?;
362        let mut read_len = CBORReadLen::from(len);
363        read_len.read_elems(3)?;
364        read_len.finish()?;
365        (|| -> Result<_, DeserializeError> {
366            let u16 = Ok(raw.unsigned_integer()? as u16)
367                .map_err(|e: DeserializeError| e.annotate("u16"))?;
368            let u162 = Ok(raw.unsigned_integer()? as u16)
369                .map_err(|e: DeserializeError| e.annotate("u162"))?;
370            let u8 = Ok(raw.unsigned_integer()? as u8)
371                .map_err(|e: DeserializeError| e.annotate("u8"))?;
372            match len {
373                cbor_event::Len::Len(_) => (),
374                cbor_event::Len::Indefinite => match raw.special()? {
375                    cbor_event::Special::Break => (),
376                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
377                },
378            }
379            Ok(ByronBlockVersion { u16, u162, u8 })
380        })()
381        .map_err(|e| e.annotate("ByronBlockVersion"))
382    }
383}
384
385impl cbor_event::se::Serialize for ByronSoftwareVersion {
386    fn serialize<'se, W: Write>(
387        &self,
388        serializer: &'se mut Serializer<W>,
389    ) -> cbor_event::Result<&'se mut Serializer<W>> {
390        serializer.write_array(cbor_event::Len::Len(2))?;
391        serializer.write_text(&self.application_name)?;
392        serializer.write_unsigned_integer(self.u32 as u64)?;
393        Ok(serializer)
394    }
395}
396
397impl Deserialize for ByronSoftwareVersion {
398    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
399        let len = raw.array()?;
400        let mut read_len = CBORReadLen::from(len);
401        read_len.read_elems(2)?;
402        read_len.finish()?;
403        (|| -> Result<_, DeserializeError> {
404            let application_name = Ok(raw.text()? as String)
405                .map_err(|e: DeserializeError| e.annotate("application_name"))?;
406            let u32 = Ok(raw.unsigned_integer()? as u32)
407                .map_err(|e: DeserializeError| e.annotate("u32"))?;
408            match len {
409                cbor_event::Len::Len(_) => (),
410                cbor_event::Len::Indefinite => match raw.special()? {
411                    cbor_event::Special::Break => (),
412                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
413                },
414            }
415            Ok(ByronSoftwareVersion {
416                application_name,
417                u32,
418            })
419        })()
420        .map_err(|e| e.annotate("ByronSoftwareVersion"))
421    }
422}
423
424impl cbor_event::se::Serialize for ByronTxFeePolicy {
425    fn serialize<'se, W: Write>(
426        &self,
427        serializer: &'se mut Serializer<W>,
428    ) -> cbor_event::Result<&'se mut Serializer<W>> {
429        serializer.write_array(cbor_event::Len::Len(2))?;
430        serializer.write_unsigned_integer(0u64)?;
431        serializer.write_tag(24u64)?;
432        let mut index_1_inner_se = Serializer::new_vec();
433        self.index_1.serialize(&mut index_1_inner_se)?;
434        let index_1_bytes = index_1_inner_se.finalize();
435        serializer.write_bytes(&index_1_bytes)?;
436        Ok(serializer)
437    }
438}
439
440impl Deserialize for ByronTxFeePolicy {
441    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
442        let len = raw.array()?;
443        let mut read_len = CBORReadLen::from(len);
444        read_len.read_elems(2)?;
445        read_len.finish()?;
446        (|| -> Result<_, DeserializeError> {
447            (|| -> Result<_, DeserializeError> {
448                let index_0_value = raw.unsigned_integer()?;
449                if index_0_value != 0 {
450                    return Err(DeserializeFailure::FixedValueMismatch {
451                        found: Key::Uint(index_0_value),
452                        expected: Key::Uint(0),
453                    }
454                    .into());
455                }
456                Ok(())
457            })()
458            .map_err(|e| e.annotate("index_0"))?;
459            let index_1 = (|| -> Result<_, DeserializeError> {
460                match raw.tag()? {
461                    24 => {
462                        let index_1_bytes = raw.bytes()?;
463                        let inner_de = &mut Deserializer::from(std::io::Cursor::new(index_1_bytes));
464                        StdFeePolicy::deserialize(inner_de)
465                    }
466                    tag => Err(DeserializeFailure::TagMismatch {
467                        found: tag,
468                        expected: 24,
469                    }
470                    .into()),
471                }
472            })()
473            .map_err(|e| e.annotate("index_1"))?;
474            match len {
475                cbor_event::Len::Len(_) => (),
476                cbor_event::Len::Indefinite => match raw.special()? {
477                    cbor_event::Special::Break => (),
478                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
479                },
480            }
481            Ok(ByronTxFeePolicy { index_1 })
482        })()
483        .map_err(|e| e.annotate("ByronTxFeePolicy"))
484    }
485}
486
487impl cbor_event::se::Serialize for ByronUpdate {
488    fn serialize<'se, W: Write>(
489        &self,
490        serializer: &'se mut Serializer<W>,
491    ) -> cbor_event::Result<&'se mut Serializer<W>> {
492        serializer.write_array(cbor_event::Len::Len(2))?;
493        serializer.write_array(cbor_event::Len::Len(self.proposal.len() as u64))?;
494        for element in self.proposal.iter() {
495            element.serialize(serializer)?;
496        }
497        serializer.write_array(cbor_event::Len::Indefinite)?;
498        //serializer.write_array(cbor_event::Len::Len((self.votes.len()) as u64))?;
499        for element in self.votes.iter() {
500            element.serialize(serializer)?;
501        }
502        serializer.write_special(cbor_event::Special::Break)?;
503        Ok(serializer)
504    }
505}
506
507impl Deserialize for ByronUpdate {
508    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
509        let len = raw.array()?;
510        let mut read_len = CBORReadLen::from(len);
511        read_len.read_elems(2)?;
512        read_len.finish()?;
513        (|| -> Result<_, DeserializeError> {
514            let proposal = (|| -> Result<_, DeserializeError> {
515                let mut proposal_arr = Vec::new();
516                let len = raw.array()?;
517                while match len {
518                    cbor_event::Len::Len(n) => (proposal_arr.len() as u64) < n,
519                    cbor_event::Len::Indefinite => true,
520                } {
521                    if raw.cbor_type()? == cbor_event::Type::Special {
522                        assert_eq!(raw.special()?, cbor_event::Special::Break);
523                        break;
524                    }
525                    proposal_arr.push(ByronUpdateProposal::deserialize(raw)?);
526                }
527                Ok(proposal_arr)
528            })()
529            .map_err(|e| e.annotate("proposal"))?;
530            let votes = (|| -> Result<_, DeserializeError> {
531                let mut votes_arr = Vec::new();
532                let len = raw.array()?;
533                while match len {
534                    cbor_event::Len::Len(n) => (votes_arr.len() as u64) < n,
535                    cbor_event::Len::Indefinite => true,
536                } {
537                    if raw.cbor_type()? == cbor_event::Type::Special {
538                        assert_eq!(raw.special()?, cbor_event::Special::Break);
539                        break;
540                    }
541                    votes_arr.push(ByronUpdateVote::deserialize(raw)?);
542                }
543                Ok(votes_arr)
544            })()
545            .map_err(|e| e.annotate("votes"))?;
546            match len {
547                cbor_event::Len::Len(_) => (),
548                cbor_event::Len::Indefinite => match raw.special()? {
549                    cbor_event::Special::Break => (),
550                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
551                },
552            }
553            Ok(ByronUpdate { proposal, votes })
554        })()
555        .map_err(|e| e.annotate("ByronUpdate"))
556    }
557}
558
559impl cbor_event::se::Serialize for ByronUpdateData {
560    fn serialize<'se, W: Write>(
561        &self,
562        serializer: &'se mut Serializer<W>,
563    ) -> cbor_event::Result<&'se mut Serializer<W>> {
564        serializer.write_array(cbor_event::Len::Len(4))?;
565        serializer.write_bytes(self.blake2b256.to_raw_bytes())?;
566        serializer.write_bytes(self.blake2b2562.to_raw_bytes())?;
567        serializer.write_bytes(self.blake2b2563.to_raw_bytes())?;
568        serializer.write_bytes(self.blake2b2564.to_raw_bytes())?;
569        Ok(serializer)
570    }
571}
572
573impl Deserialize for ByronUpdateData {
574    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
575        let len = raw.array()?;
576        let mut read_len = CBORReadLen::from(len);
577        read_len.read_elems(4)?;
578        read_len.finish()?;
579        (|| -> Result<_, DeserializeError> {
580            let blake2b256 = raw
581                .bytes()
582                .map_err(Into::<DeserializeError>::into)
583                .and_then(|bytes| {
584                    Blake2b256::from_raw_bytes(&bytes)
585                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
586                })
587                .map_err(|e: DeserializeError| e.annotate("blake2b256"))?;
588            let blake2b2562 = raw
589                .bytes()
590                .map_err(Into::<DeserializeError>::into)
591                .and_then(|bytes| {
592                    Blake2b256::from_raw_bytes(&bytes)
593                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
594                })
595                .map_err(|e: DeserializeError| e.annotate("blake2b2562"))?;
596            let blake2b2563 = raw
597                .bytes()
598                .map_err(Into::<DeserializeError>::into)
599                .and_then(|bytes| {
600                    Blake2b256::from_raw_bytes(&bytes)
601                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
602                })
603                .map_err(|e: DeserializeError| e.annotate("blake2b2563"))?;
604            let blake2b2564 = raw
605                .bytes()
606                .map_err(Into::<DeserializeError>::into)
607                .and_then(|bytes| {
608                    Blake2b256::from_raw_bytes(&bytes)
609                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
610                })
611                .map_err(|e: DeserializeError| e.annotate("blake2b2564"))?;
612            match len {
613                cbor_event::Len::Len(_) => (),
614                cbor_event::Len::Indefinite => match raw.special()? {
615                    cbor_event::Special::Break => (),
616                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
617                },
618            }
619            Ok(ByronUpdateData {
620                blake2b256,
621                blake2b2562,
622                blake2b2563,
623                blake2b2564,
624            })
625        })()
626        .map_err(|e| e.annotate("ByronUpdateData"))
627    }
628}
629
630impl cbor_event::se::Serialize for ByronUpdateProposal {
631    fn serialize<'se, W: Write>(
632        &self,
633        serializer: &'se mut Serializer<W>,
634    ) -> cbor_event::Result<&'se mut Serializer<W>> {
635        serializer.write_array(cbor_event::Len::Len(7))?;
636        self.block_version.serialize(serializer)?;
637        self.block_version_mod.serialize(serializer)?;
638        self.software_version.serialize(serializer)?;
639        serializer.write_map(cbor_event::Len::Len(self.data.len() as u64))?;
640        for (key, value) in self.data.iter() {
641            serializer.write_text(key)?;
642            value.serialize(serializer)?;
643        }
644        serializer.write_map(cbor_event::Len::Len(self.byron_attributes.len() as u64))?;
645        for (key, value) in self.byron_attributes.iter() {
646            key.serialize(serializer)?;
647            value.serialize(serializer)?;
648        }
649        serializer.write_bytes(&self.from)?;
650        serializer.write_bytes(&self.signature)?;
651        Ok(serializer)
652    }
653}
654
655impl Deserialize for ByronUpdateProposal {
656    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
657        let len = raw.array()?;
658        let mut read_len = CBORReadLen::from(len);
659        read_len.read_elems(7)?;
660        read_len.finish()?;
661        (|| -> Result<_, DeserializeError> {
662            let block_version = ByronBlockVersion::deserialize(raw)
663                .map_err(|e: DeserializeError| e.annotate("block_version"))?;
664            let block_version_mod = Bvermod::deserialize(raw)
665                .map_err(|e: DeserializeError| e.annotate("block_version_mod"))?;
666            let software_version = ByronSoftwareVersion::deserialize(raw)
667                .map_err(|e: DeserializeError| e.annotate("software_version"))?;
668            let data = (|| -> Result<_, DeserializeError> {
669                let mut data_table = BTreeMap::new();
670                let data_len = raw.map()?;
671                while match data_len {
672                    cbor_event::Len::Len(n) => (data_table.len() as u64) < n,
673                    cbor_event::Len::Indefinite => true,
674                } {
675                    if raw.cbor_type()? == cbor_event::Type::Special {
676                        assert_eq!(raw.special()?, cbor_event::Special::Break);
677                        break;
678                    }
679                    let data_key = raw.text()? as String;
680                    let data_value = ByronUpdateData::deserialize(raw)?;
681                    if data_table.insert(data_key.clone(), data_value).is_some() {
682                        return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
683                            "some complicated/unsupported type",
684                        )))
685                        .into());
686                    }
687                }
688                Ok(data_table)
689            })()
690            .map_err(|e| e.annotate("data"))?;
691            let byron_attributes = (|| -> Result<_, DeserializeError> {
692                let mut byron_attributes_table = BTreeMap::new();
693                let byron_attributes_len = raw.map()?;
694                while match byron_attributes_len {
695                    cbor_event::Len::Len(n) => (byron_attributes_table.len() as u64) < n,
696                    cbor_event::Len::Indefinite => true,
697                } {
698                    if raw.cbor_type()? == cbor_event::Type::Special {
699                        assert_eq!(raw.special()?, cbor_event::Special::Break);
700                        break;
701                    }
702                    let byron_attributes_key = ByronAny::deserialize(raw)?;
703                    let byron_attributes_value = ByronAny::deserialize(raw)?;
704                    if byron_attributes_table
705                        .insert(byron_attributes_key.clone(), byron_attributes_value)
706                        .is_some()
707                    {
708                        return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from(
709                            "some complicated/unsupported type",
710                        )))
711                        .into());
712                    }
713                }
714                Ok(byron_attributes_table)
715            })()
716            .map_err(|e| e.annotate("byron_attributes"))?;
717            let from =
718                Ok(raw.bytes()? as Vec<u8>).map_err(|e: DeserializeError| e.annotate("from"))?;
719            let signature = Ok(raw.bytes()? as Vec<u8>)
720                .map_err(|e: DeserializeError| e.annotate("signature"))?;
721            match len {
722                cbor_event::Len::Len(_) => (),
723                cbor_event::Len::Indefinite => match raw.special()? {
724                    cbor_event::Special::Break => (),
725                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
726                },
727            }
728            Ok(ByronUpdateProposal {
729                block_version,
730                block_version_mod,
731                software_version,
732                data,
733                byron_attributes,
734                from,
735                signature,
736            })
737        })()
738        .map_err(|e| e.annotate("ByronUpdateProposal"))
739    }
740}
741
742impl cbor_event::se::Serialize for ByronUpdateVote {
743    fn serialize<'se, W: Write>(
744        &self,
745        serializer: &'se mut Serializer<W>,
746    ) -> cbor_event::Result<&'se mut Serializer<W>> {
747        serializer.write_array(cbor_event::Len::Len(4))?;
748        serializer.write_bytes(&self.voter)?;
749        serializer.write_bytes(self.proposal_id.to_raw_bytes())?;
750        serializer.write_special(cbor_event::Special::Bool(self.vote))?;
751        serializer.write_bytes(&self.signature)?;
752        Ok(serializer)
753    }
754}
755
756impl Deserialize for ByronUpdateVote {
757    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
758        let len = raw.array()?;
759        let mut read_len = CBORReadLen::from(len);
760        read_len.read_elems(4)?;
761        read_len.finish()?;
762        (|| -> Result<_, DeserializeError> {
763            let voter =
764                Ok(raw.bytes()? as Vec<u8>).map_err(|e: DeserializeError| e.annotate("voter"))?;
765            let proposal_id = raw
766                .bytes()
767                .map_err(Into::<DeserializeError>::into)
768                .and_then(|bytes| {
769                    Blake2b256::from_raw_bytes(&bytes)
770                        .map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into())
771                })
772                .map_err(|e: DeserializeError| e.annotate("proposal_id"))?;
773            let vote = raw
774                .bool()
775                .map_err(Into::into)
776                .map_err(|e: DeserializeError| e.annotate("vote"))?;
777            let signature = Ok(raw.bytes()? as Vec<u8>)
778                .map_err(|e: DeserializeError| e.annotate("signature"))?;
779            match len {
780                cbor_event::Len::Len(_) => (),
781                cbor_event::Len::Indefinite => match raw.special()? {
782                    cbor_event::Special::Break => (),
783                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
784                },
785            }
786            Ok(ByronUpdateVote {
787                voter,
788                proposal_id,
789                vote,
790                signature,
791            })
792        })()
793        .map_err(|e| e.annotate("ByronUpdateVote"))
794    }
795}
796
797impl cbor_event::se::Serialize for SoftForkRule {
798    fn serialize<'se, W: Write>(
799        &self,
800        serializer: &'se mut Serializer<W>,
801    ) -> cbor_event::Result<&'se mut Serializer<W>> {
802        serializer.write_array(cbor_event::Len::Len(3))?;
803        serializer.write_unsigned_integer(self.coin_portion)?;
804        serializer.write_unsigned_integer(self.coin_portion2)?;
805        serializer.write_unsigned_integer(self.coin_portion3)?;
806        Ok(serializer)
807    }
808}
809
810impl Deserialize for SoftForkRule {
811    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
812        let len = raw.array()?;
813        let mut read_len = CBORReadLen::from(len);
814        read_len.read_elems(3)?;
815        read_len.finish()?;
816        (|| -> Result<_, DeserializeError> {
817            let coin_portion = Ok(raw.unsigned_integer()?)
818                .map_err(|e: DeserializeError| e.annotate("coin_portion"))?;
819            let coin_portion2 = Ok(raw.unsigned_integer()?)
820                .map_err(|e: DeserializeError| e.annotate("coin_portion2"))?;
821            let coin_portion3 = Ok(raw.unsigned_integer()?)
822                .map_err(|e: DeserializeError| e.annotate("coin_portion3"))?;
823            match len {
824                cbor_event::Len::Len(_) => (),
825                cbor_event::Len::Indefinite => match raw.special()? {
826                    cbor_event::Special::Break => (),
827                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
828                },
829            }
830            Ok(SoftForkRule {
831                coin_portion,
832                coin_portion2,
833                coin_portion3,
834            })
835        })()
836        .map_err(|e| e.annotate("SoftForkRule"))
837    }
838}
839
840impl cbor_event::se::Serialize for StdFeePolicy {
841    fn serialize<'se, W: Write>(
842        &self,
843        serializer: &'se mut Serializer<W>,
844    ) -> cbor_event::Result<&'se mut Serializer<W>> {
845        serializer.write_array(cbor_event::Len::Len(2))?;
846        // hand-edit to call our serialize instead
847        cml_core::serialization::Serialize::serialize(&self.big_integer, serializer, true)?;
848        cml_core::serialization::Serialize::serialize(&self.big_integer2, serializer, true)?;
849
850        Ok(serializer)
851    }
852}
853
854impl Deserialize for StdFeePolicy {
855    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
856        let len = raw.array()?;
857        let mut read_len = CBORReadLen::from(len);
858        read_len.read_elems(2)?;
859        read_len.finish()?;
860        (|| -> Result<_, DeserializeError> {
861            let big_integer = BigInteger::deserialize(raw)
862                .map_err(|e: DeserializeError| e.annotate("big_integer"))?;
863            let big_integer2 = BigInteger::deserialize(raw)
864                .map_err(|e: DeserializeError| e.annotate("big_integer2"))?;
865            match len {
866                cbor_event::Len::Len(_) => (),
867                cbor_event::Len::Indefinite => match raw.special()? {
868                    cbor_event::Special::Break => (),
869                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
870                },
871            }
872            Ok(StdFeePolicy {
873                big_integer,
874                big_integer2,
875            })
876        })()
877        .map_err(|e| e.annotate("StdFeePolicy"))
878    }
879}
cml_multi_era/byron/update/serialization.rs

cml_multi_era/byron/update/
serialization.rs
