fix: check reserved type names for contract types

Author: mootz12

soroban-sdk-macros/src/lib.rs

@@ -40,6 +40,7 @@ use derive_trait::derive_trait;
 
 use darling::{ast::NestedMeta, FromMeta};
 use macro_string::MacroString;
+use map_type::is_reserved_type_name;
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote, ToTokens};
@@ -421,6 +422,17 @@ pub fn contracttype(metadata: TokenStream, input: TokenStream) -> TokenStream {
     let vis = &input.vis;
     let ident = &input.ident;
     let attrs = &input.attrs;
+    if is_reserved_type_name(&ident.to_string()) {
+        return Error::new(
+            ident.span(),
+            format!(
+                "type name `{}` conflicts with a Soroban type and cannot be used as a contract type name",
+                ident,
+            ),
+        )
+        .to_compile_error()
+        .into();
+    }
     // If the export argument has a value, do as it instructs regarding
     // exporting. If it does not have a value, export if the type is pub,
     // or always export when spec shaking is enabled.

soroban-sdk-macros/src/map_type.rs

@@ -21,6 +21,57 @@ pub const BN254_FP_SERIALIZED_SIZE: u32 = 32;
 pub const BN254_G1_SERIALIZED_SIZE: u32 = BN254_FP_SERIALIZED_SIZE * 2; // 64
 pub const BN254_G2_SERIALIZED_SIZE: u32 = BN254_G1_SERIALIZED_SIZE * 2; // 128
 
+/// Returns true if `name` matches a built-in Soroban type that is
+/// recognized by `map_type`. Types with these names cannot be used as
+/// `#[contracttype]` names because `map_type` would silently classify them
+/// as built-in types instead of user-defined types in the contract spec.
+pub fn is_reserved_type_name(name: &str) -> bool {
+    matches!(
+        name,
+        // Non-generic built-in types
+        "Val"
+            | "u64"
+            | "i64"
+            | "u32"
+            | "i32"
+            | "u128"
+            | "i128"
+            | "U256"
+            | "I256"
+            | "bool"
+            | "Symbol"
+            | "String"
+            | "Error"
+            | "Bytes"
+            | "Address"
+            | "MuxedAddress"
+            | "Timepoint"
+            | "Duration"
+            // BLS12-381 types (unprefixed)
+            | "Fp"
+            | "Fp2"
+            | "G1Affine"
+            | "G2Affine"
+            | "Fr"
+            // BLS12-381 types (prefixed)
+            | "Bls12381Fp"
+            | "Bls12381Fp2"
+            | "Bls12381G1Affine"
+            | "Bls12381G2Affine"
+            // BN254 types
+            | "Bn254Fp"
+            | "Bn254G1Affine"
+            | "Bn254G2Affine"
+            // Generic built-in types
+            | "Result"
+            | "Option"
+            | "Vec"
+            | "Map"
+            | "BytesN"
+            | "Hash"
+    )
+}
+
 #[allow(clippy::too_many_lines)]
 pub fn map_type(t: &Type, allow_ref: bool, allow_hash: bool) -> Result<ScSpecTypeDef, Error> {
     match t {
@@ -299,4 +350,59 @@ mod test {
             }))
         );
     }
+
+    #[test]
+    fn test_is_reserved_type_name() {
+        // Non-generic built-in types
+        assert!(is_reserved_type_name("Val"));
+        assert!(is_reserved_type_name("u64"));
+        assert!(is_reserved_type_name("i64"));
+        assert!(is_reserved_type_name("u32"));
+        assert!(is_reserved_type_name("i32"));
+        assert!(is_reserved_type_name("u128"));
+        assert!(is_reserved_type_name("i128"));
+        assert!(is_reserved_type_name("U256"));
+        assert!(is_reserved_type_name("I256"));
+        assert!(is_reserved_type_name("bool"));
+        assert!(is_reserved_type_name("Symbol"));
+        assert!(is_reserved_type_name("String"));
+        assert!(is_reserved_type_name("Error"));
+        assert!(is_reserved_type_name("Bytes"));
+        assert!(is_reserved_type_name("Address"));
+        assert!(is_reserved_type_name("MuxedAddress"));
+        assert!(is_reserved_type_name("Timepoint"));
+        assert!(is_reserved_type_name("Duration"));
+
+        // BLS12-381 types (unprefixed)
+        assert!(is_reserved_type_name("Fp"));
+        assert!(is_reserved_type_name("Fp2"));
+        assert!(is_reserved_type_name("G1Affine"));
+        assert!(is_reserved_type_name("G2Affine"));
+        assert!(is_reserved_type_name("Fr"));
+
+        // BLS12-381 types (prefixed)
+        assert!(is_reserved_type_name("Bls12381Fp"));
+        assert!(is_reserved_type_name("Bls12381Fp2"));
+        assert!(is_reserved_type_name("Bls12381G1Affine"));
+        assert!(is_reserved_type_name("Bls12381G2Affine"));
+
+        // BN254 types
+        assert!(is_reserved_type_name("Bn254Fp"));
+        assert!(is_reserved_type_name("Bn254G1Affine"));
+        assert!(is_reserved_type_name("Bn254G2Affine"));
+
+        // Generic built-in types
+        assert!(is_reserved_type_name("Result"));
+        assert!(is_reserved_type_name("Option"));
+        assert!(is_reserved_type_name("Vec"));
+        assert!(is_reserved_type_name("Map"));
+        assert!(is_reserved_type_name("BytesN"));
+        assert!(is_reserved_type_name("Hash"));
+
+        // Non-reserved names
+        assert!(!is_reserved_type_name("MyStruct"));
+        assert!(!is_reserved_type_name("Token"));
+        assert!(!is_reserved_type_name("MyAddress"));
+        assert!(!is_reserved_type_name("address"));
+    }
 }