lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

serialization.rs (5987B)


      1 //! Closed value codecs. Successful decoding still proves no stock authority.
      2 use super::{
      3     ObligationBacking, PhysicalBalances, PoolBalances, PoolSnapshot, PoolUnit, StockTicks,
      4 };
      5 use crate::{PoolId, Sequence, listing::MeasurementUnit};
      6 use core::fmt;
      7 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
      8 
      9 #[derive(Clone, Copy)]
     10 struct Scale(u8);
     11 impl Serialize for Scale {
     12     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
     13         serializer.collect_str(&self.0)
     14     }
     15 }
     16 impl<'de> Deserialize<'de> for Scale {
     17     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
     18         struct Visitor;
     19         impl de::Visitor<'_> for Visitor {
     20             type Value = Scale;
     21             fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     22                 f.write_str("one canonical pool precision string from0 through6")
     23             }
     24             fn visit_str<E: de::Error>(self, value: &str) -> Result<Scale, E> {
     25                 match value.as_bytes() {
     26                     [byte @ b'0'..=b'6'] => Ok(Scale(byte - b'0')),
     27                     _ => Err(E::custom("invalid pool precision")),
     28                 }
     29             }
     30         }
     31         deserializer.deserialize_str(Visitor)
     32     }
     33 }
     34 #[derive(Serialize, Deserialize)]
     35 #[serde(deny_unknown_fields)]
     36 struct Unit {
     37     unit: MeasurementUnit,
     38     scale: Scale,
     39 }
     40 impl Serialize for PoolUnit {
     41     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
     42         Unit {
     43             unit: self.unit(),
     44             scale: Scale(self.scale()),
     45         }
     46         .serialize(serializer)
     47     }
     48 }
     49 impl<'de> Deserialize<'de> for PoolUnit {
     50     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
     51         let wire: Unit = object(deserializer)?;
     52         Self::new(wire.unit, wire.scale.0).map_err(de::Error::custom)
     53     }
     54 }
     55 #[derive(Serialize, Deserialize)]
     56 #[serde(deny_unknown_fields)]
     57 struct Physical {
     58     available: StockTicks,
     59     preparatory_hold: StockTicks,
     60     committed_hold: StockTicks,
     61     physical_quarantine: StockTicks,
     62     consumed: StockTicks,
     63     waste: StockTicks,
     64     removed: StockTicks,
     65 }
     66 impl Serialize for PhysicalBalances {
     67     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
     68         Physical {
     69             available: self.available,
     70             preparatory_hold: self.preparatory_hold,
     71             committed_hold: self.committed_hold,
     72             physical_quarantine: self.physical_quarantine,
     73             consumed: self.consumed,
     74             waste: self.waste,
     75             removed: self.removed,
     76         }
     77         .serialize(serializer)
     78     }
     79 }
     80 impl<'de> Deserialize<'de> for PhysicalBalances {
     81     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
     82         let v: Physical = object(deserializer)?;
     83         Ok(Self {
     84             available: v.available,
     85             preparatory_hold: v.preparatory_hold,
     86             committed_hold: v.committed_hold,
     87             physical_quarantine: v.physical_quarantine,
     88             consumed: v.consumed,
     89             waste: v.waste,
     90             removed: v.removed,
     91         })
     92     }
     93 }
     94 #[derive(Serialize, Deserialize)]
     95 #[serde(deny_unknown_fields)]
     96 struct Balances {
     97     introduced: StockTicks,
     98     physical: PhysicalBalances,
     99 }
    100 impl Serialize for PoolBalances {
    101     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
    102         Balances {
    103             introduced: self.introduced(),
    104             physical: self.physical(),
    105         }
    106         .serialize(serializer)
    107     }
    108 }
    109 impl<'de> Deserialize<'de> for PoolBalances {
    110     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
    111         let v: Balances = object(deserializer)?;
    112         Self::new(v.introduced, v.physical).map_err(de::Error::custom)
    113     }
    114 }
    115 #[derive(Serialize, Deserialize)]
    116 #[serde(deny_unknown_fields)]
    117 struct Backing {
    118     remaining: StockTicks,
    119     backed: StockTicks,
    120     deficit: StockTicks,
    121 }
    122 impl Serialize for ObligationBacking {
    123     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
    124         Backing {
    125             remaining: self.remaining(),
    126             backed: self.backed(),
    127             deficit: self.deficit(),
    128         }
    129         .serialize(serializer)
    130     }
    131 }
    132 impl<'de> Deserialize<'de> for ObligationBacking {
    133     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
    134         let value: Backing = object(deserializer)?;
    135         Self::new(value.remaining, value.backed, value.deficit).map_err(de::Error::custom)
    136     }
    137 }
    138 
    139 #[derive(Serialize, Deserialize)]
    140 #[serde(deny_unknown_fields)]
    141 struct Snapshot {
    142     id: PoolId,
    143     unit: PoolUnit,
    144     balances: PoolBalances,
    145     version: Sequence,
    146 }
    147 impl Serialize for PoolSnapshot {
    148     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
    149         Snapshot {
    150             id: self.id(),
    151             unit: self.unit(),
    152             balances: self.balances(),
    153             version: self.version(),
    154         }
    155         .serialize(serializer)
    156     }
    157 }
    158 impl<'de> Deserialize<'de> for PoolSnapshot {
    159     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
    160         let v: Snapshot = object(deserializer)?;
    161         Ok(Self::new(v.id, v.unit, v.balances, v.version))
    162     }
    163 }
    164 
    165 pub(super) fn object<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
    166     deserializer: D,
    167 ) -> Result<T, D::Error> {
    168     struct Visitor<T>(core::marker::PhantomData<T>);
    169     impl<'de, T: Deserialize<'de>> de::Visitor<'de> for Visitor<T> {
    170         type Value = T;
    171         fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    172             f.write_str("a closed stock value object")
    173         }
    174         fn visit_map<A: de::MapAccess<'de>>(self, map: A) -> Result<T, A::Error> {
    175             T::deserialize(de::value::MapAccessDeserializer::new(map))
    176         }
    177     }
    178     deserializer.deserialize_map(Visitor(core::marker::PhantomData))
    179 }