Rollback cyberpunk test related codes

Author: BigtoC

contracts/cyberpunk/Cargo.lock

@@ -28,7 +28,6 @@ cosmwasm-std = { path = "../../packages/std", default-features = false, features
 ] }
 rust-argon2 = "2.1"
 thiserror = "1.0.26"
-serde_json = "1.0.117"
 
 [dev-dependencies]
 cosmwasm-vm = { path = "../../packages/vm", default-features = false }

contracts/cyberpunk/Cargo.toml

@@ -225,7 +225,6 @@ mod tests {
         message_info, mock_dependencies, mock_env, MockApi, MockQuerier, MockStorage,
     };
     use cosmwasm_std::{from_json, DenomMetadata, DenomUnit, OwnedDeps};
-    use serde_json::{json, Error};
 
     fn setup() -> OwnedDeps<MockStorage, MockApi, MockQuerier> {
         let mut deps = mock_dependencies();
@@ -293,161 +292,4 @@ mod tests {
 
         assert_eq!(denom.symbol, "FOO0");
     }
-
-    #[test]
-    fn query_denom_metadata_with_null_denom_units_works() {
-        // Test case with null denom_units - should deserialize as empty vec
-        let json_with_null_denom_units = json!({
-            "description": "Test Token",
-            "denom_units": null,
-            "base": "utest",
-            "display": "TEST",
-            "name": "Test Token",
-            "symbol": "TEST",
-            "uri": "https://test.com",
-            "uri_hash": "hash"
-        });
-
-        let metadata_with_null_denom_units: DenomMetadata =
-            serde_json::from_value(json_with_null_denom_units).unwrap();
-        assert_eq!(
-            metadata_with_null_denom_units.denom_units,
-            Vec::<DenomUnit>::default()
-        );
-        assert!(metadata_with_null_denom_units.denom_units.is_empty());
-
-        // Test normal case with provided denom_units
-        let json_with_units = json!({
-            "description": "Test Token",
-            "denom_units": [
-                {
-                    "denom": "utest",
-                    "exponent": 6,
-                    "aliases": ["microtest"]
-                }
-            ],
-            "base": "utest",
-            "display": "TEST",
-            "name": "Test Token",
-            "symbol": "TEST",
-            "uri": "https://test.com",
-            "uri_hash": "hash"
-        });
-
-        let metadata_with_units: DenomMetadata = serde_json::from_value(json_with_units).unwrap();
-        assert_eq!(metadata_with_units.denom_units.len(), 1);
-        assert_eq!(metadata_with_units.denom_units[0].denom, "utest");
-        assert_eq!(metadata_with_units.denom_units[0].aliases.len(), 1);
-        assert_eq!(metadata_with_units.denom_units[0].aliases[0], "microtest");
-
-        // Test with null aliases inside denom_units - should deserialize as empty vec
-        let json_with_null_aliases = json!({
-            "description": "Test Token",
-            "denom_units": [
-                {
-                    "denom": "utest",
-                    "exponent": 6,
-                    "aliases": null
-                }
-            ],
-            "base": "utest",
-            "display": "TEST",
-            "name": "Test Token",
-            "symbol": "TEST",
-            "uri": "https://test.com",
-            "uri_hash": "hash"
-        });
-
-        let metadata_with_null_aliases: DenomMetadata =
-            serde_json::from_value(json_with_null_aliases).unwrap();
-        assert_eq!(metadata_with_null_aliases.denom_units.len(), 1);
-        assert_eq!(
-            metadata_with_null_aliases.denom_units[0].aliases,
-            Vec::<String>::default()
-        );
-        assert!(metadata_with_null_aliases.denom_units[0].aliases.is_empty());
-    }
-
-    #[test]
-    fn query_denom_metadata_with_missing_fields_fails() {
-        // Missing denom_units should be treated as default value (empty vec)
-        let json_missing_denom_units = json!({
-            "description": "Test Token",
-            "base": "utest",
-            "display": "TEST",
-            "name": "Test Token",
-            "symbol": "TEST",
-            "uri": "https://test.com",
-            "uri_hash": "hash"
-        });
-
-        let json_missing_denom_units_metadata: Result<DenomMetadata, Error> =
-            serde_json::from_value(json_missing_denom_units);
-        assert!(json_missing_denom_units_metadata.is_err());
-
-        // Missing aliases field should be treated as default (empty vec)
-        let json_missing_aliases = json!({
-            "description": "Test Token",
-            "denom_units": [
-                {
-                    "denom": "utest",
-                    "exponent": 6
-                }
-            ],
-            "base": "utest",
-            "display": "TEST",
-            "name": "Test Token",
-            "symbol": "TEST",
-            "uri": "https://test.com",
-            "uri_hash": "hash"
-        });
-
-        let missing_aliases_metadata: Result<DenomMetadata, Error> =
-            serde_json::from_value(json_missing_aliases);
-        assert!(missing_aliases_metadata.is_err());
-    }
-
-    #[test]
-    fn query_denom_metadata_with_mixed_null_and_value_works() {
-        // Test with multiple denom units, some with null aliases and some with values
-        let mixed_json = json!({
-            "description": "Mixed Token",
-            "denom_units": [
-                {
-                    "denom": "unit1",
-                    "exponent": 0,
-                    "aliases": null
-                },
-                {
-                    "denom": "unit2",
-                    "exponent": 6,
-                    "aliases": ["microunit", "u"]
-                },
-                {
-                    "denom": "unit3",
-                    "exponent": 9,
-                    "aliases": []
-                }
-            ],
-            "base": "unit1",
-            "display": "MIXED",
-            "name": "Mixed Token",
-            "symbol": "MIX",
-            "uri": "https://mixed.token",
-            "uri_hash": "hash123"
-        });
-
-        let metadata: DenomMetadata = serde_json::from_value(mixed_json).unwrap();
-
-        // First denom unit has null aliases, should be empty vec
-        assert!(metadata.denom_units[0].aliases.is_empty());
-
-        // Second has two aliases
-        assert_eq!(metadata.denom_units[1].aliases.len(), 2);
-        assert_eq!(metadata.denom_units[1].aliases[0], "microunit");
-        assert_eq!(metadata.denom_units[1].aliases[1], "u");
-
-        // Third has explicitly empty aliases
-        assert!(metadata.denom_units[2].aliases.is_empty());
-    }
 }