cli support

Author: rahxephon89

crates/aptos/src/common/types.rs

@@ -2699,12 +2699,14 @@ impl EntryFunctionArgumentsJSON {
                     && struct_tag.address == move_core_types::account_address::AccountAddress::ONE;
 
                 if is_option && arg_json.value.is_array() {
-                    // Option<T> with vector format: [] for None, [value] for Some
+                    // Option<T> with legacy vector format: [] for None, [value] for Some
                     let array = arg_json.value.as_array().unwrap();
                     let (variant, fields) = if array.is_empty() {
-                        ("None", vec![])
+                        ("None", serde_json::Map::new())
                     } else if array.len() == 1 {
-                        ("Some", array.clone())
+                        let mut map = serde_json::Map::new();
+                        map.insert("0".to_string(), array[0].clone());
+                        ("Some", map)
                     } else {
                         return Err(CliError::CommandArgumentError(format!(
                             "Option<T> as vector must have 0 or 1 elements, got {}",
@@ -2713,7 +2715,7 @@ impl EntryFunctionArgumentsJSON {
                     };
 
                     let bcs_bytes = parser
-                        .construct_enum_argument(&struct_tag, variant, &fields)
+                        .construct_enum_argument(&struct_tag, variant, &fields, 0)
                         .await?;
 
                     args.push(ArgWithType {
@@ -2724,44 +2726,59 @@ impl EntryFunctionArgumentsJSON {
                         _vector_depth: 0,
                         arg: bcs_bytes,
                     });
-                } else if let Some(variant) = arg_json.value.get("variant").and_then(|v| v.as_str())
-                {
-                    // Check if this is an enum variant (has a "variant" field)
-                    // Parse as enum
-                    let fields = arg_json
-                        .value
-                        .get("fields")
-                        .and_then(|v| v.as_array())
-                        .ok_or_else(|| {
-                            CliError::CommandArgumentError(format!(
-                                "Enum argument must have 'fields' array for variant '{}'",
-                                variant
-                            ))
-                        })?;
-
-                    let bcs_bytes = parser
-                        .construct_enum_argument(&struct_tag, variant, fields)
-                        .await?;
-
-                    args.push(ArgWithType {
-                        _ty: FunctionArgType::Enum {
-                            type_tag: struct_tag,
-                            variant: variant.to_string(),
-                        },
-                        _vector_depth: 0,
-                        arg: bcs_bytes,
-                    });
-                } else {
-                    // Parse as struct
-                    let field_values = arg_json.value.as_object().ok_or_else(|| {
-                        CliError::CommandArgumentError(format!(
-                            "Struct argument must be a JSON object, got: {}",
-                            arg_json.value
-                        ))
-                    })?;
+                } else if arg_json.value.is_object() {
+                    // Value is an object - could be struct or enum
+                    let obj = arg_json.value.as_object().unwrap();
+
+                    // Check if it's an enum variant (single key with variant name)
+                    // or a struct (multiple keys or special struct detection)
+                    if obj.len() == 1 {
+                        // Single key - could be enum variant
+                        let (potential_variant_name, variant_fields_value) =
+                            obj.iter().next().unwrap();
+
+                        // Check if the value is an object (enum fields) or something else
+                        if let Some(fields_obj) = variant_fields_value.as_object() {
+                            // Looks like enum format: { "VariantName": { ...fields... } }
+                            // Try to parse as enum first
+                            let bcs_bytes = parser
+                                .construct_enum_argument(
+                                    &struct_tag,
+                                    potential_variant_name,
+                                    fields_obj,
+                                    0,
+                                )
+                                .await;
+
+                            match bcs_bytes {
+                                Ok(bytes) => {
+                                    // Successfully parsed as enum
+                                    args.push(ArgWithType {
+                                        _ty: FunctionArgType::Enum {
+                                            type_tag: struct_tag,
+                                            variant: potential_variant_name.to_string(),
+                                        },
+                                        _vector_depth: 0,
+                                        arg: bytes,
+                                    });
+                                    continue;
+                                },
+                                Err(e) => {
+                                    // If it failed with "is a struct, not an enum", try as struct
+                                    if e.to_string().contains("is a struct, not an enum") {
+                                        // Fall through to struct parsing
+                                    } else {
+                                        // Other error - propagate it
+                                        return Err(e);
+                                    }
+                                },
+                            }
+                        }
+                    }
 
+                    // Parse as struct (either multi-key object or single-key that failed enum parsing)
                     let bcs_bytes = parser
-                        .construct_struct_argument(&struct_tag, field_values)
+                        .construct_struct_argument(&struct_tag, obj, 0)
                         .await?;
 
                     args.push(ArgWithType {
@@ -2771,6 +2788,11 @@ impl EntryFunctionArgumentsJSON {
                         _vector_depth: 0,
                         arg: bcs_bytes,
                     });
+                } else {
+                    return Err(CliError::CommandArgumentError(format!(
+                        "Invalid value for type {}. Expected object, got: {}",
+                        arg_json.arg_type, arg_json.value
+                    )));
                 }
             } else {
                 // Parse as primitive type