Merge pull request #220 from RGB-WG/armor

Use new ASCII armoring technique

Author: dr-orlovsky

Cargo.lock

@@ -23,9 +23,10 @@ required-features = ["stl"]
 
 [dependencies]
 amplify = { version = "~4.6.0", features = ["rand"] }
+ascii-armor = "0.2.0"
 strict_encoding = "~2.7.0-beta.1"
-strict_types = "~2.7.0-beta.1"
-aluvm = { version = "~0.11.0-beta.4", features = ["std"] }
+strict_types = { version = "~2.7.0-beta.2", features = ["armor"] }
+aluvm = { version = "~0.11.0-beta.4", features = ["std", "ascii-armor"] }
 commit_verify = { version = "~0.11.0-beta.4", features = ["rand", "derive"] }
 single_use_seals = "~0.11.0-beta.4"
 bp-core = { version = "~0.11.0-beta.4" }
@@ -59,4 +60,8 @@ getrandom = { version = "0.2", features = ["js"] }
 wasm-bindgen-test = "0.3"
 
 [package.metadata.docs.rs]
-features = [ "all" ]
+features = ["all"]
+
+[patch.crates-io]
+commit_verify = { git = "https://github.com/LNP-BP/client_side_validation", branch = "master" }
+bp-core = { git = "https://github.com/BP-WG/bp-core", branch = "master" }

Cargo.toml

@@ -26,6 +26,7 @@ use std::str::FromStr;
 
 use amplify::confinement::{TinyOrdMap, TinyOrdSet};
 use amplify::{ByteArray, Bytes32};
+use armor::StrictArmor;
 use baid58::{Baid58ParseError, Chunking, FromBaid58, ToBaid58, CHUNKING_32};
 use commit_verify::{CommitEncode, CommitEngine, CommitId, CommitmentId, DigestExt, Sha256};
 use strict_encoding::{StrictDecode, StrictDeserialize, StrictEncode, StrictSerialize, StrictType};
@@ -227,6 +228,13 @@ impl<Root: SchemaRoot> Schema<Root> {
     }
 }
 
+impl<Root: SchemaRoot> StrictArmor for Schema<Root> {
+    type Id = SchemaId;
+    const PLATE_TITLE: &'static str = "RGB SCHEMA";
+
+    fn armor_id(&self) -> Self::Id { self.schema_id() }
+}
+
 #[cfg(test)]
 mod test {
     use strict_encoding::StrictDumb;

src/schema/schema.rs

@@ -105,23 +105,43 @@ impl Default for Types {
     fn default() -> Self { Types::Strict(none!()) }
 }
 
+impl Types {
+    pub fn as_strict(&self) -> &TypeSystem {
+        match self {
+            Types::Strict(ts) => ts,
+        }
+    }
+}
+
 #[cfg(feature = "serde")]
 mod _serde {
+    use armor::AsciiArmor;
+    use serde_crate::de::Error;
     use serde_crate::{Deserialize, Deserializer, Serialize, Serializer};
 
     use super::*;
 
     impl Serialize for Types {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: Serializer {
-            serializer.serialize_str(&self.to_string())
+            if serializer.is_human_readable() {
+                serializer.serialize_str(&self.as_strict().to_ascii_armored_string())
+            } else {
+                self.as_strict().serialize(serializer)
+            }
         }
     }
 
     impl<'de> Deserialize<'de> for Types {
-        fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer<'de> {
-            todo!()
+            if deserializer.is_human_readable() {
+                let s = String::deserialize(deserializer)?;
+                let sys = TypeSystem::from_ascii_armored_str(&s).map_err(D::Error::custom)?;
+                Ok(Types::Strict(sys))
+            } else {
+                Ok(Types::Strict(TypeSystem::deserialize(deserializer)?))
+            }
         }
     }
 }

src/schema/script.rs

@@ -34,7 +34,7 @@ use crate::{
 
 /// Strict types id for the library providing data types for RGB consensus.
 pub const LIB_ID_RGB: &str =
-    "urn:ubideco:stl:BSZqoDzjgGJxgRUwLUEJ7FZC74RV87ighGBsbx59AUPa#package-rapid-record";
+    "urn:ubideco:stl:6NAFZspAZ14Y1NynHeQBJVNqep4arKkKx8zchhHrESvr#airport-border-match";
 
 fn _rgb_core_stl() -> Result<TypeLib, CompileError> {
     LibBuilder::new(libname!(LIB_NAME_RGB), tiny_bset! {

src/stl.rs

@@ -133,26 +133,35 @@ pub struct AluLib(pub aluvm::library::Lib);
 
 #[cfg(feature = "serde")]
 mod _serde {
-    use serde_crate::ser::Error;
+    use aluvm::library::Lib;
+    use armor::AsciiArmor;
+    use serde_crate::de::Error;
     use serde_crate::{Deserialize, Deserializer, Serialize, Serializer};
 
     use super::*;
 
     impl Serialize for AluLib {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: Serializer {
-            let mut buf = Vec::<u8>::new();
-            self.print_disassemble::<RgbIsa>(&mut buf)
-                .map_err(S::Error::custom)?;
-            let s = String::from_utf8(buf).map_err(S::Error::custom)?;
-            serializer.serialize_str(&s)
+            if serializer.is_human_readable() {
+                serializer.serialize_str(&self.0.to_ascii_armored_string())
+            } else {
+                Serialize::serialize(&self.0, serializer)
+            }
         }
     }
 
     impl<'de> Deserialize<'de> for AluLib {
-        fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer<'de> {
-            todo!()
+            if deserializer.is_human_readable() {
+                let s: String = Deserialize::deserialize(deserializer)?;
+                let lib = Lib::from_ascii_armored_str(&s).map_err(D::Error::custom)?;
+                Ok(lib.into())
+            } else {
+                let lib: Lib = Deserialize::deserialize(deserializer)?;
+                Ok(lib.into())
+            }
         }
     }
 }