Manual PlutusData Json implementation

Author: szg251

src/plutus_data.rs

@@ -1,6 +1,12 @@
 //! Plutus Data related types and traits
 #[cfg(feature = "lbf")]
-use lbr_prelude::json::Json;
+use data_encoding::HEXLOWER;
+#[cfg(feature = "lbf")]
+use lbr_prelude::error::Error;
+#[cfg(feature = "lbf")]
+use lbr_prelude::json::{
+    case_json_constructor, case_json_object, json_constructor, json_object, Json,
+};
 use num_bigint::BigInt;
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -9,7 +15,6 @@ use serde::{Deserialize, Serialize};
 
 /// Data representation of on-chain data such as Datums and Redeemers
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "lbf", derive(Json))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum PlutusData {
     Constr(BigInt, Vec<PlutusData>),
@@ -19,6 +24,122 @@ pub enum PlutusData {
     Bytes(Vec<u8>),
 }
 
+#[cfg(feature = "lbf")]
+impl Json for PlutusData {
+    fn to_json(&self) -> serde_json::Value {
+        match self {
+            PlutusData::Constr(index, fields) => json_constructor(
+                "Constr",
+                vec![json_object(vec![
+                    ("index".to_string(), index.to_json()),
+                    ("fields".to_string(), fields.to_json()),
+                ])],
+            ),
+            PlutusData::Map(map) => json_constructor("Map", vec![map.to_json()]),
+            PlutusData::List(list) => json_constructor("List", vec![list.to_json()]),
+            PlutusData::Integer(int) => json_constructor("Integer", vec![int.to_json()]),
+            PlutusData::Bytes(bytes) => {
+                json_constructor("Bytes", vec![String::to_json(&HEXLOWER.encode(bytes))])
+            }
+        }
+    }
+
+    fn from_json(value: &serde_json::Value) -> Result<PlutusData, Error> {
+        case_json_constructor(
+            "PlutusV1.PlutusData",
+            vec![
+                (
+                    "Constr",
+                    Box::new(|ctor_fields| match &ctor_fields[..] {
+                        [val] => case_json_object(
+                            |obj| {
+                                let index = obj.get("index").ok_or(Error::UnexpectedFieldName {
+                                    wanted: "index".to_owned(),
+                                    got: obj.keys().cloned().collect(),
+                                    parser: "PlutusV1.PlutusData".to_owned(),
+                                })?;
+
+                                let fields =
+                                    obj.get("fields").ok_or(Error::UnexpectedFieldName {
+                                        wanted: "fields".to_owned(),
+                                        got: obj.keys().cloned().collect(),
+                                        parser: "PlutusV1.PlutusData".to_owned(),
+                                    })?;
+                                Ok(PlutusData::Constr(
+                                    BigInt::from_json(index)?,
+                                    <Vec<PlutusData>>::from_json(fields)?,
+                                ))
+                            },
+                            val,
+                        ),
+                        _ => Err(Error::UnexpectedArrayLength {
+                            wanted: 1,
+                            got: ctor_fields.len(),
+                            parser: "Prelude.Maybe".to_owned(),
+                        }),
+                    }),
+                ),
+                (
+                    "Map",
+                    Box::new(|ctor_fields| match &ctor_fields[..] {
+                        [val] => Ok(PlutusData::Map(Json::from_json(val)?)),
+                        _ => Err(Error::UnexpectedArrayLength {
+                            wanted: 1,
+                            got: ctor_fields.len(),
+                            parser: "Prelude.Maybe".to_owned(),
+                        }),
+                    }),
+                ),
+                (
+                    "List",
+                    Box::new(|ctor_fields| match &ctor_fields[..] {
+                        [val] => Ok(PlutusData::List(Json::from_json(val)?)),
+                        _ => Err(Error::UnexpectedArrayLength {
+                            wanted: 1,
+                            got: ctor_fields.len(),
+                            parser: "Prelude.Maybe".to_owned(),
+                        }),
+                    }),
+                ),
+                (
+                    "Integer",
+                    Box::new(|ctor_fields| match &ctor_fields[..] {
+                        [val] => Ok(PlutusData::Integer(Json::from_json(val)?)),
+                        _ => Err(Error::UnexpectedArrayLength {
+                            wanted: 1,
+                            got: ctor_fields.len(),
+                            parser: "Prelude.Maybe".to_owned(),
+                        }),
+                    }),
+                ),
+                (
+                    "Bytes",
+                    Box::new(|ctor_fields| match &ctor_fields[..] {
+                        [val] => {
+                            let bytes = String::from_json(val).and_then(|str| {
+                                HEXLOWER.decode(&str.into_bytes()).map_err(|_| {
+                                    Error::UnexpectedJsonInvariant {
+                                        wanted: "base16 string".to_owned(),
+                                        got: "unexpected string".to_owned(),
+                                        parser: "Plutus.V1.Bytes".to_owned(),
+                                    }
+                                })
+                            })?;
+                            Ok(PlutusData::Bytes(bytes))
+                        }
+                        _ => Err(Error::UnexpectedArrayLength {
+                            wanted: 1,
+                            got: ctor_fields.len(),
+                            parser: "Prelude.Maybe".to_owned(),
+                        }),
+                    }),
+                ),
+            ],
+            value,
+        )
+    }
+}
+
 impl PlutusData {
     pub fn constr(tag: u32, fields: Vec<PlutusData>) -> Self {
         PlutusData::Constr(BigInt::from(tag), fields)