feat(primitives): Enable serde of ledger structs (#169)

pallas-addresses/src/byron.rs

@@ -12,7 +12,7 @@ pub type Blake2b224 = Hash<28>;
 pub type AddressId = Blake2b224;
 pub type StakeholderId = Blake2b224;
 
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AddrDistr {
     Variant0(StakeholderId),
     Variant1,
@@ -57,7 +57,7 @@ impl minicbor::Encode<()> for AddrDistr {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AddrType {
     PubKey,
     Script,
@@ -98,7 +98,7 @@ impl<C> minicbor::Encode<C> for AddrType {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AddrAttrProperty {
     AddrDistr(AddrDistr),
     Bytes(ByteVec),
@@ -148,7 +148,7 @@ impl<C> minicbor::Encode<C> for AddrAttrProperty {
 
 pub type AddrAttr = OrderPreservingProperties<AddrAttrProperty>;
 
-#[derive(Debug, Encode, Decode, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Encode, Decode, Clone, PartialEq, Eq, PartialOrd)]
 pub struct AddressPayload {
     #[n(0)]
     pub root: AddressId,
@@ -161,7 +161,7 @@ pub struct AddressPayload {
 }
 
 /// New type wrapping a Byron address primitive
-#[derive(Debug, Encode, Decode, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Encode, Decode, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ByronAddress {
     #[n(0)]
     payload: TagWrap<ByteVec, 24>,

pallas-addresses/src/lib.rs

@@ -63,7 +63,7 @@ pub type TxIdx = u64;
 pub type CertIdx = u64;
 
 /// An on-chain pointer to a stake key
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Pointer(Slot, TxIdx, CertIdx);
 
 fn slice_to_hash(slice: &[u8]) -> Result<Hash<28>, Error> {
@@ -113,7 +113,7 @@ impl Pointer {
 }
 
 /// The payment part of a Shelley address
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub enum ShelleyPaymentPart {
     Key(PaymentKeyHash),
     Script(ScriptHash),
@@ -151,7 +151,7 @@ impl ShelleyPaymentPart {
 }
 
 /// The delegation part of a Shelley address
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub enum ShelleyDelegationPart {
     Key(StakeKeyHash),
     Script(ScriptHash),
@@ -212,7 +212,7 @@ impl StakePayload {
 }
 
 /// The network tag of an address
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]
 pub enum Network {
     Testnet,
     Mainnet,
@@ -230,24 +230,24 @@ impl From<u8> for Network {
 }
 
 /// A decoded Shelley address
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub struct ShelleyAddress(Network, ShelleyPaymentPart, ShelleyDelegationPart);
 
 /// The payload of a Stake address
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub enum StakePayload {
     Stake(StakeKeyHash),
     Script(ScriptHash),
 }
 
 /// A decoded Stake address
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub struct StakeAddress(Network, StakePayload);
 
 pub use byron::ByronAddress;
 
 /// A decoded Cardano address of any type
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 pub enum Address {
     Byron(ByronAddress),
     Shelley(ShelleyAddress),
@@ -345,7 +345,7 @@ parse_stake_fn!(parse_type_14, stake_key);
 parse_stake_fn!(parse_type_15, script);
 
 fn bytes_to_address(bytes: &[u8]) -> Result<Address, Error> {
-    let header = *bytes.get(0).ok_or(Error::MissingHeader)?;
+    let header = *bytes.first().ok_or(Error::MissingHeader)?;
     let payload = &bytes[1..];
 
     match header & 0b1111_0000 {

pallas-codec/Cargo.toml

@@ -13,5 +13,7 @@ authors = [
 ]
 
 [dependencies]
+hex = "0.4.3"
 minicbor = { version = "0.17", features = ["std", "half", "derive"] }
+serde = { version = "1.0.143", features = ["derive"] }
 

pallas-codec/src/utils.rs

@@ -1,6 +1,6 @@
-use std::ops::Deref;
-
 use minicbor::{data::Tag, Decode, Encode};
+use serde::{Deserialize, Serialize};
+use std::ops::Deref;
 
 /// Utility for skipping parts of the CBOR payload, use only for debugging
 #[derive(Debug, PartialEq, PartialOrd, Eq, Ord)]
@@ -43,6 +43,21 @@ pub enum KeyValuePairs<K, V> {
     Indef(Vec<(K, V)>),
 }
 
+impl<K, V> KeyValuePairs<K, V> {
+    pub fn to_vec(self) -> Vec<(K, V)> {
+        self.into()
+    }
+}
+
+impl<K, V> From<KeyValuePairs<K, V>> for Vec<(K, V)> {
+    fn from(other: KeyValuePairs<K, V>) -> Self {
+        match other {
+            KeyValuePairs::Def(x) => x,
+            KeyValuePairs::Indef(x) => x,
+        }
+    }
+}
+
 impl<K, V> Deref for KeyValuePairs<K, V> {
     type Target = Vec<(K, V)>;
 
@@ -117,6 +132,12 @@ pub enum MaybeIndefArray<A> {
     Indef(Vec<A>),
 }
 
+impl<A> MaybeIndefArray<A> {
+    pub fn to_vec(self) -> Vec<A> {
+        self.into()
+    }
+}
+
 impl<A> Deref for MaybeIndefArray<A> {
     type Target = Vec<A>;
 
@@ -128,6 +149,15 @@ impl<A> Deref for MaybeIndefArray<A> {
     }
 }
 
+impl<A> From<MaybeIndefArray<A>> for Vec<A> {
+    fn from(other: MaybeIndefArray<A>) -> Self {
+        match other {
+            MaybeIndefArray::Def(x) => x,
+            MaybeIndefArray::Indef(x) => x,
+        }
+    }
+}
+
 impl<'b, C, A> minicbor::decode::Decode<'b, C> for MaybeIndefArray<A>
 where
     A: minicbor::decode::Decode<'b, C>,
@@ -186,7 +216,7 @@ where
 /// transform key-value structures into an orderer vec of `properties`, where
 /// each entry represents a a cbor-encodable variant of an attribute of the
 /// struct.
-#[derive(Debug, PartialEq, Clone, PartialOrd)]
+#[derive(Debug, PartialEq, Eq, Clone, PartialOrd)]
 pub struct OrderPreservingProperties<P>(Vec<P>);
 
 impl<P> Deref for OrderPreservingProperties<P> {
@@ -229,7 +259,8 @@ where
 }
 
 /// Wraps a struct so that it is encoded/decoded as a cbor bytes
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd)]
+#[serde(transparent)]
 pub struct CborWrap<T>(pub T);
 
 impl<'b, C, T> minicbor::Decode<'b, C> for CborWrap<T>
@@ -273,7 +304,7 @@ impl<T> Deref for CborWrap<T> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct TagWrap<I, const T: u64>(pub I);
 
 impl<I, const T: u64> TagWrap<I, T> {
@@ -526,7 +557,7 @@ impl From<&AnyUInt> for u64 {
 /// let confirm: (u16, u16) = minicbor::decode(keeper.raw_cbor()).unwrap();
 /// assert_eq!(confirm, (456u16, 789u16));
 /// ```
-#[derive(Debug, PartialEq, PartialOrd, Clone)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub struct KeepRaw<'b, T> {
     raw: &'b [u8],
     inner: T,
@@ -536,6 +567,10 @@ impl<'b, T> KeepRaw<'b, T> {
     pub fn raw_cbor(&self) -> &'b [u8] {
         self.raw
     }
+
+    pub fn unwrap(self) -> T {
+        self.inner
+    }
 }
 
 impl<'b, T> Deref for KeepRaw<'b, T> {
@@ -575,16 +610,37 @@ impl<C, T> minicbor::Encode<C> for KeepRaw<'_, T> {
     }
 }
 
-#[derive(Clone, Debug)]
-pub enum Nullable<T> {
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(from = "Option::<T>", into = "Option::<T>")]
+pub enum Nullable<T>
+where
+    T: std::clone::Clone,
+{
     Some(T),
     Null,
     Undefined,
 }
 
+impl<T> Nullable<T>
+where
+    T: std::clone::Clone,
+{
+    pub fn map<F, O>(self, f: F) -> Nullable<O>
+    where
+        O: std::clone::Clone,
+        F: Fn(T) -> O,
+    {
+        match self {
+            Nullable::Some(x) => Nullable::Some(f(x)),
+            Nullable::Null => Nullable::Null,
+            Nullable::Undefined => Nullable::Undefined,
+        }
+    }
+}
+
 impl<'b, C, T> minicbor::Decode<'b, C> for Nullable<T>
 where
-    T: minicbor::Decode<'b, C>,
+    T: minicbor::Decode<'b, C> + std::clone::Clone,
 {
     fn decode(d: &mut minicbor::Decoder<'b>, ctx: &mut C) -> Result<Self, minicbor::decode::Error> {
         match d.datatype()? {
@@ -606,7 +662,7 @@ where
 
 impl<C, T> minicbor::Encode<C> for Nullable<T>
 where
-    T: minicbor::Encode<C>,
+    T: minicbor::Encode<C> + std::clone::Clone,
 {
     fn encode<W: minicbor::encode::Write>(
         &self,
@@ -630,11 +686,103 @@ where
     }
 }
 
-impl<T> From<Option<T>> for Nullable<T> {
+impl<T> From<Option<T>> for Nullable<T>
+where
+    T: std::clone::Clone,
+{
     fn from(x: Option<T>) -> Self {
         match x {
             Some(x) => Nullable::Some(x),
             None => Nullable::Null,
         }
     }
 }
+
+impl<T> From<Nullable<T>> for Option<T>
+where
+    T: std::clone::Clone,
+{
+    fn from(other: Nullable<T>) -> Self {
+        match other {
+            Nullable::Some(x) => Some(x),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Encode, Decode, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[cbor(transparent)]
+#[serde(into = "String")]
+#[serde(try_from = "String")]
+pub struct Bytes(#[n(0)] minicbor::bytes::ByteVec);
+
+impl From<Vec<u8>> for Bytes {
+    fn from(xs: Vec<u8>) -> Self {
+        Bytes(minicbor::bytes::ByteVec::from(xs))
+    }
+}
+
+impl From<Bytes> for Vec<u8> {
+    fn from(b: Bytes) -> Self {
+        b.0.into()
+    }
+}
+
+impl Deref for Bytes {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.deref()
+    }
+}
+
+impl TryFrom<String> for Bytes {
+    type Error = hex::FromHexError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        let v = hex::decode(value)?;
+        Ok(Bytes(minicbor::bytes::ByteVec::from(v)))
+    }
+}
+
+impl From<Bytes> for String {
+    fn from(b: Bytes) -> Self {
+        hex::encode(b.deref())
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Encode, Decode, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[cbor(transparent)]
+#[serde(into = "i128")]
+#[serde(try_from = "i128")]
+pub struct Int(#[n(0)] pub minicbor::data::Int);
+
+impl Deref for Int {
+    type Target = minicbor::data::Int;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<Int> for i128 {
+    fn from(value: Int) -> Self {
+        i128::from(value.0)
+    }
+}
+
+impl From<i64> for Int {
+    fn from(x: i64) -> Self {
+        let inner = minicbor::data::Int::from(x);
+        Self(inner)
+    }
+}
+
+impl TryFrom<i128> for Int {
+    type Error = minicbor::data::TryFromIntError;
+
+    fn try_from(value: i128) -> Result<Self, Self::Error> {
+        let inner = minicbor::data::Int::try_from(value)?;
+        Ok(Self(inner))
+    }
+}