New metadata format

abi/Cargo.toml

@@ -23,6 +23,7 @@ type-metadata = { git = "https://github.com/type-metadata/type-metadata.git", de
 
 [dev-dependencies]
 serde_json = "1.0"
+assert-json-diff = "1.0.1"
 
 [features]
 default = [

abi/src/layout.rs

@@ -17,7 +17,6 @@ use alloc::{
     string::String,
     vec::Vec,
 };
-use core::fmt::Write;
 
 use derive_more::From;
 use serde::{
@@ -44,7 +43,7 @@ pub trait HasLayout {
 /// Either a concrete layout bound or another layout sub-struct.
 #[derive(Debug, PartialEq, Eq, Serialize, From)]
 #[serde(bound = "F::TypeId: Serialize")]
-#[serde(untagged)]
+#[serde(rename_all = "lowercase")]
 pub enum StorageLayout<F: Form = MetaForm> {
     /// A concrete layout bound.
     Range(LayoutRange<F>),
@@ -81,10 +80,9 @@ pub struct LayoutKey(
 #[derive(Debug, PartialEq, Eq, Serialize)]
 #[serde(bound = "F::TypeId: Serialize")]
 pub struct LayoutStruct<F: Form = MetaForm> {
-    #[serde(rename = "struct.type")]
+    #[serde(rename = "type")]
     self_ty: F::TypeId,
     /// The sub-fields of the struct.
-    #[serde(rename = "struct.fields")]
     fields: Vec<LayoutField<F>>,
 }
 
@@ -163,13 +161,12 @@ impl IntoCompact for LayoutField {
 #[serde(bound = "F::TypeId: Serialize")]
 pub struct LayoutRange<F: Form = MetaForm> {
     /// The single key for cells or the starting key address for chunks.
-    #[serde(rename = "range.offset", serialize_with = "serialize_key")]
+    #[serde(serialize_with = "serialize_key")]
     offset: LayoutKey,
     /// The amount of associated key addresses starting from the offset key.
-    #[serde(rename = "range.len")]
     len: u32,
     /// The element type stored under the associated keys.
-    #[serde(rename = "range.elem_type")]
+    #[serde(rename = "elemType")]
     elem_ty: F::TypeId,
 }
 
@@ -215,47 +212,5 @@ fn serialize_key<S>(key: &LayoutKey, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {
-    let bytes = key.0;
-    let mut hex = String::with_capacity(bytes.len() * 2 + 2);
-    write!(hex, "0x").expect("failed writing to string");
-    for byte in &bytes {
-        write!(hex, "{:02x}", byte).expect("failed writing to string");
-    }
-
-    serializer.serialize_str(&hex)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use type_metadata::{
-        form::{
-            Form,
-            MetaForm,
-        },
-        IntoCompact,
-        Registry,
-    };
-
-    #[test]
-    fn key_must_serialize_to_hex() {
-        // given
-        let type_id = <MetaForm as Form>::TypeId::new::<u32>();
-        let offset = LayoutKey([1; 32]);
-        let cs: LayoutRange<MetaForm> = LayoutRange {
-            offset,
-            len: 1337,
-            elem_ty: type_id,
-        };
-        let mut registry = Registry::new();
-
-        // when
-        let json = serde_json::to_string(&cs.into_compact(&mut registry)).unwrap();
-
-        // then
-        assert_eq!(
-            json,
-            "{\"range.offset\":\"0x0101010101010101010101010101010101010101010101010101010101010101\",\"range.len\":1337,\"range.elem_type\":1}"
-        );
-    }
+    super::hex_encode(&key.0[..], serializer)
 }

abi/src/lib.rs

@@ -17,6 +17,9 @@
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 
+#[cfg(test)]
+mod tests;
+
 mod layout;
 mod specs;
 
@@ -51,7 +54,11 @@ pub use self::{
     },
 };
 
-use serde::Serialize;
+use core::fmt::Write as _;
+use serde::{
+    Serialize,
+    Serializer,
+};
 use type_metadata::{
     form::CompactForm,
     IntoCompact as _,
@@ -83,3 +90,15 @@ impl InkProject {
         }
     }
 }
+
+fn hex_encode<S>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut hex = String::with_capacity(bytes.len() * 2 + 2);
+    write!(hex, "0x").expect("failed writing to string");
+    for byte in bytes {
+        write!(hex, "{:02x}", byte).expect("failed writing to string");
+    }
+    serializer.serialize_str(&hex)
+}

abi/src/specs.rs

@@ -295,6 +295,7 @@ impl ConstructorSpecBuilder<state::Selector> {
 /// Describes a contract message.
 #[derive(Debug, PartialEq, Eq, Serialize)]
 #[serde(bound = "F::TypeId: Serialize")]
+#[serde(rename_all = "camelCase")]
 pub struct MessageSpec<F: Form = MetaForm> {
     /// The name of the message.
     name: F::String,
@@ -571,6 +572,7 @@ pub type DisplayName<F> = type_metadata::Namespace<F>;
 /// simply be a type alias to `fn(i32, i32) -> Ordering`.
 #[derive(Debug, PartialEq, Eq, Serialize)]
 #[serde(bound = "F::TypeId: Serialize")]
+#[serde(rename_all = "camelCase")]
 pub struct TypeSpec<F: Form = MetaForm> {
     /// The actual type.
     ty: F::TypeId,
@@ -830,36 +832,5 @@ fn serialize_selector<S>(s: &[u8; 4], serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {
-    let hex = format!(
-        r#"["0x{:02X}","0x{:02X}","0x{:02X}","0x{:02X}"]"#,
-        s[0], s[1], s[2], s[3]
-    );
-    serializer.serialize_str(&hex)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn construct_selector_must_serialize_to_hex() {
-        // given
-        let name = "foo";
-        let cs: ConstructorSpec<MetaForm> = ConstructorSpec {
-            name,
-            selector: 123_456_789u32.to_be_bytes(),
-            args: Vec::new(),
-            docs: Vec::new(),
-        };
-        let mut registry = Registry::new();
-
-        // when
-        let json = serde_json::to_string(&cs.into_compact(&mut registry)).unwrap();
-
-        // then
-        assert_eq!(
-            json,
-            r#"{"name":1,"selector":"[\"0x07\",\"0x5B\",\"0xCD\",\"0x15\"]","args":[],"docs":[]}"#
-        );
-    }
+    super::hex_encode(&s[..], serializer)
 }