feat: improvements to Argument (#967) (#1101)

* feat: improvements to Argument (#967)

* feat: improvements to Argument

* display

* #[serde(rename = "Argument")]

* fix?

* remove tag

* fix

* Update crates/iota-sdk-types/src/transaction/mod.rs

Co-authored-by: Roman Overko <[email protected]>

---------

Co-authored-by: Roman Overko <[email protected]>

Author: thibault-martinez

crates/iota-sdk-types/src/transaction/mod.rs

@@ -907,7 +907,7 @@ pub struct Upgrade {
 /// argument-result         = %d02 u16
 /// argument-nested-result  = %d03 u16 u16
 /// ```
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
 #[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
 #[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
 #[non_exhaustive]
@@ -927,6 +927,17 @@ pub enum Argument {
     NestedResult(u16, u16),
 }
 
+impl std::fmt::Display for Argument {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Argument::Gas => write!(f, "Gas"),
+            Argument::Input(i) => write!(f, "Input({i})"),
+            Argument::Result(i) => write!(f, "Result({i})"),
+            Argument::NestedResult(i, j) => write!(f, "NestedResult({i}, {j})"),
+        }
+    }
+}
+
 impl Argument {
     crate::def_is!(Gas, Input, Result, NestedResult);
 

crates/iota-sdk-types/src/transaction/serialization.rs

@@ -485,25 +485,20 @@ mod argument {
     use super::*;
 
     #[derive(serde::Serialize, serde::Deserialize)]
-    #[serde(rename = "Argument", untagged, rename_all = "lowercase")]
+    #[serde(rename = "Argument")]
     enum ReadableArgument {
         /// # Gas
-        Gas(Gas),
+        Gas,
         /// # Input
-        Input { input: u16 },
+        Input(u16),
         /// # Result
-        Result { result: u16 },
+        Result(u16),
         /// # NestedResult
-        NestedResult { result: (u16, u16) },
-    }
-
-    #[derive(serde::Serialize, serde::Deserialize)]
-    #[serde(rename_all = "lowercase")]
-    enum Gas {
-        Gas,
+        NestedResult(u16, u16),
     }
 
     #[derive(serde::Serialize, serde::Deserialize)]
+    #[serde(rename = "Argument")]
     enum BinaryArgument {
         Gas,
         Input(u16),
@@ -518,12 +513,12 @@ mod argument {
         {
             if serializer.is_human_readable() {
                 let readable = match *self {
-                    Argument::Gas => ReadableArgument::Gas(Gas::Gas),
-                    Argument::Input(input) => ReadableArgument::Input { input },
-                    Argument::Result(result) => ReadableArgument::Result { result },
-                    Argument::NestedResult(result, subresult) => ReadableArgument::NestedResult {
-                        result: (result, subresult),
-                    },
+                    Argument::Gas => ReadableArgument::Gas,
+                    Argument::Input(input) => ReadableArgument::Input(input),
+                    Argument::Result(result) => ReadableArgument::Result(result),
+                    Argument::NestedResult(result, subresult) => {
+                        ReadableArgument::NestedResult(result, subresult)
+                    }
                 };
                 readable.serialize(serializer)
             } else {
@@ -547,12 +542,12 @@ mod argument {
         {
             if deserializer.is_human_readable() {
                 ReadableArgument::deserialize(deserializer).map(|readable| match readable {
-                    ReadableArgument::Gas(_) => Argument::Gas,
-                    ReadableArgument::Input { input } => Argument::Input(input),
-                    ReadableArgument::Result { result } => Argument::Result(result),
-                    ReadableArgument::NestedResult {
-                        result: (result, subresult),
-                    } => Argument::NestedResult(result, subresult),
+                    ReadableArgument::Gas => Argument::Gas,
+                    ReadableArgument::Input(input) => Argument::Input(input),
+                    ReadableArgument::Result(result) => Argument::Result(result),
+                    ReadableArgument::NestedResult(result, subresult) => {
+                        Argument::NestedResult(result, subresult)
+                    }
                 })
             } else {
                 BinaryArgument::deserialize(deserializer).map(|binary| match binary {
@@ -883,12 +878,12 @@ mod tests {
     #[test]
     fn argument() {
         let test_cases = [
-            (Argument::Gas, serde_json::json!("gas")),
-            (Argument::Input(1), serde_json::json!({"input": 1})),
-            (Argument::Result(2), serde_json::json!({"result": 2})),
+            (Argument::Gas, serde_json::json!("Gas")),
+            (Argument::Input(1), serde_json::json!({"Input": 1})),
+            (Argument::Result(2), serde_json::json!({"Result": 2})),
             (
                 Argument::NestedResult(3, 4),
-                serde_json::json!({"result": [3, 4]}),
+                serde_json::json!({"NestedResult": [3, 4]}),
             ),
         ];