@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/common-macros/src/storage.rs

@@ -6,18 +6,14 @@ use heck::ToSnakeCase;
 use itertools::Itertools;
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
-use syn::{Attribute, Expr, Fields, FieldsNamed, Type, Variant};
+use syn::{Attribute, Expr, Fields, FieldsNamed, Meta, Type, Variant};
 
 // ============================================================================
 // Public API
 // ============================================================================
 
 /// Generates the storage API from the `#[storage]` attribute macro.
-pub fn generate_storage(attr: TokenStream, input: TokenStream) -> TokenStream {
-    if !attr.is_empty() {
-        panic!("the #[storage] attribute does not accept arguments");
-    }
-
+pub fn generate_storage(input: TokenStream) -> TokenStream {
     let item_enum: syn::ItemEnum = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse enum: {}", e));
     let enum_name = &item_enum.ident;
     let vis = &item_enum.vis;
@@ -33,13 +29,6 @@ pub fn generate_storage(attr: TokenStream, input: TokenStream) -> TokenStream {
     }
 }
 
-/// Checks if a type is a primitive (pass-by-value) type.
-pub(crate) fn is_primitive_type(ty: &Type) -> bool {
-    const PRIMITIVES: &[&str] = &["u32", "i32", "u64", "i64", "u128", "i128", "bool"];
-    matches!(ty, Type::Path(p) if p.path.segments.len() == 1
-        && PRIMITIVES.contains(&p.path.segments[0].ident.to_string().as_str()))
-}
-
 // ============================================================================
 // Types
 // ============================================================================
@@ -66,32 +55,6 @@ impl StorageKind {
         let method = format_ident!("{}", self.name());
         quote! { env.storage().#method() }
     }
-
-    /// Generates TTL extension code.
-    ///
-    /// - `use_stored_config=true`: reads TTL config from storage (for auto-extension)
-    /// - `use_stored_config=false`: uses local `threshold`/`extend_to` variables (for manual)
-    fn gen_ttl_extension(self, use_stored_config: bool) -> TokenStream {
-        let accessor = self.accessor();
-        let extend_call = if self == Self::Instance {
-            quote! { #accessor.extend_ttl(threshold, extend_to); }
-        } else {
-            quote! { #accessor.extend_ttl(&key, threshold, extend_to); }
-        };
-
-        if use_stored_config {
-            let method = format_ident!("{}", self.name());
-            quote! {
-                if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) =
-                    utils::ttl_configurable::TtlConfigStorage::#method(env)
-                {
-                    #extend_call
-                }
-            }
-        } else {
-            extend_call
-        }
-    }
 }
 
 /// Parsed configuration for a storage enum variant.
@@ -148,28 +111,33 @@ fn gen_accessor_methods(enum_name: &Ident, variant: &Variant) -> TokenStream {
     let accessor = config.kind.accessor();
     let value_type = &config.value_type;
 
-    // TTL extension tokens
-    let auto_ttl = if config.auto_ttl { config.kind.gen_ttl_extension(true) } else { TokenStream::new() };
-    let manual_ttl = config.kind.gen_ttl_extension(false);
+    // Auto TTL extension call — emitted after reads/writes for persistent storage.
+    // `Option<TokenStream>` integrates directly with `quote!` (None emits nothing).
+    let extend_ttl = config.auto_ttl.then(|| {
+        quote! { utils::ttl_configurable::extend_persistent_ttl(env, &key); }
+    });
 
-    // Getter return type and expression
+    // Getter: returns the value directly (with default) or wrapped in Option.
     let (ret_type, ret_expr) = match &config.default_value {
         Some(default) => (quote! { #value_type }, quote! { value.unwrap_or(#default) }),
         None => (quote! { Option<#value_type> }, quote! { value }),
     };
-    let ttl_on_get = if config.auto_ttl {
-        quote! { if value.is_some() { #auto_ttl } }
-    } else {
-        TokenStream::new()
-    };
+    let ttl_on_get = extend_ttl.as_ref().map(|call| quote! { if value.is_some() { #call } });
 
-    // Has check body
-    let has_body = if config.auto_ttl {
-        quote! { let exists = #accessor.has(&key); if exists { #auto_ttl } exists }
-    } else {
-        quote! { #accessor.has(&key) }
+    // Has: conditionally extend TTL when key exists.
+    let has_body = match &extend_ttl {
+        Some(call) => quote! { let exists = #accessor.has(&key); if exists { #call } exists },
+        None => quote! { #accessor.has(&key) },
     };
 
+    // TTL extender method — only for persistent/temporary storage (instance has no per-key TTL).
+    let ttl_extender_method = (config.kind != StorageKind::Instance).then(|| quote! {
+        pub fn #ttl_extender(#params, threshold: u32, extend_to: u32) {
+            let key = #key;
+            #accessor.extend_ttl(&key, threshold, extend_to);
+        }
+    });
+
     quote! {
         pub fn #getter(#params) -> #ret_type {
             let key = #key;
@@ -181,7 +149,7 @@ fn gen_accessor_methods(enum_name: &Ident, variant: &Variant) -> TokenStream {
         pub fn #setter(#params, value: &#value_type) {
             let key = #key;
             #accessor.set(&key, value);
-            #auto_ttl
+            #extend_ttl
         }
 
         pub fn #remover(#params) {
@@ -201,10 +169,7 @@ fn gen_accessor_methods(enum_name: &Ident, variant: &Variant) -> TokenStream {
             #has_body
         }
 
-        pub fn #ttl_extender(#params, threshold: u32, extend_to: u32) {
-            let key = #key;
-            #manual_ttl
-        }
+        #ttl_extender_method
     }
 }
 
@@ -244,7 +209,7 @@ fn gen_args(variant: &Variant) -> TokenStream {
     if fields.is_empty() {
         quote! { env }
     } else {
-        let names = fields.iter().map(|(name, _)| *name);
+        let names = fields.iter().map(|(name, _)| name);
         quote! { env, #(#names),* }
     }
 }
@@ -268,6 +233,14 @@ fn gen_key(enum_name: &Ident, variant: &Variant) -> TokenStream {
     }
 }
 
+/// Checks if a type is a primitive (pass-by-value) type.
+fn is_primitive_type(ty: &Type) -> bool {
+    // https://developers.stellar.org/docs/learn/fundamentals/contract-development/types/built-in-types#primitive-types
+    const PRIMITIVES: &[&str] = &["u32", "i32", "u64", "i64", "u128", "i128", "bool"];
+    matches!(ty, Type::Path(p) if p.path.segments.len() == 1
+        && PRIMITIVES.contains(&p.path.segments[0].ident.to_string().as_str()))
+}
+
 // ============================================================================
 // Attribute Parsing
 // ============================================================================
@@ -329,7 +302,10 @@ fn parse_storage_type(attrs: &[Attribute]) -> Result<(StorageKind, Type), String
                 "temporary" => StorageKind::Temporary,
                 _ => return None,
             };
-            Some((kind, attr.parse_args::<Type>().ok()?))
+            let value_type = attr
+                .parse_args::<Type>()
+                .unwrap_or_else(|e| panic!("failed to parse storage type for #[{}(...)] : {}", ident, e));
+            Some((kind, value_type))
         })
         .exactly_one()
         .map_err(|e| {
@@ -346,7 +322,7 @@ fn parse_default(attrs: &[Attribute]) -> Result<Option<Expr>, String> {
         .iter()
         .filter(|attr| attr.path().is_ident("default"))
         .at_most_one()
-        .map_err(|_| "multiple default values specified")?
+        .map_err(|e| format!("multiple default values specified: {}", e))?
         .map(|attr| attr.parse_args::<Expr>())
         .transpose()
         .map_err(|e| format!("failed to parse default value: {}", e))
@@ -357,17 +333,188 @@ fn parse_name(attrs: &[Attribute]) -> Result<Option<String>, String> {
         .iter()
         .filter(|attr| attr.path().is_ident("name"))
         .at_most_one()
-        .map_err(|_| "multiple name attributes specified")?
+        .map_err(|e| format!("multiple name attributes specified: {}", e))?
         .map(|attr| attr.parse_args::<syn::LitStr>().map(|lit| lit.value()))
         .transpose()
         .map_err(|e| format!("failed to parse name attribute: {}", e))
 }
 
 fn parse_no_ttl_extension(attrs: &[Attribute]) -> Result<bool, String> {
-    Ok(attrs
+    let attr = attrs
         .iter()
         .filter(|attr| attr.path().is_ident("no_ttl_extension"))
         .at_most_one()
-        .map_err(|_| "multiple #[no_ttl_extension] attributes specified")?
-        .is_some())
+        .map_err(|e| format!("multiple #[no_ttl_extension] attributes specified: {}", e))?;
+
+    // Reject `#[no_ttl_extension(...)]` / `#[no_ttl_extension = ...]`
+    match attr {
+        None => Ok(false),
+        Some(attr) if matches!(attr.meta, Meta::Path(_)) => Ok(true),
+        Some(_) => Err("#[no_ttl_extension] does not accept arguments".to_string()),
+    }
+}
+
+// ============================================================================
+// Test-only Functions
+// ============================================================================
+
+#[cfg(test)]
+pub(crate) mod test {
+    use super::*;
+
+    // ========================================================================
+    // VariantConfigInfo - wrapper struct for test access
+    // ========================================================================
+
+    /// Test-only wrapper struct exposing VariantConfig data without exposing the type.
+    #[derive(Debug, Clone)]
+    pub struct VariantConfigInfo {
+        pub name: String,
+        pub kind_name: String,
+        pub value_type: String,
+        pub has_default: bool,
+        pub auto_ttl: bool,
+    }
+
+    // ========================================================================
+    // StorageKind wrapper functions
+    // ========================================================================
+
+    /// Returns the name for Instance storage kind.
+    pub fn storage_kind_instance_name() -> &'static str {
+        StorageKind::Instance.name()
+    }
+
+    /// Returns the name for Persistent storage kind.
+    pub fn storage_kind_persistent_name() -> &'static str {
+        StorageKind::Persistent.name()
+    }
+
+    /// Returns the name for Temporary storage kind.
+    pub fn storage_kind_temporary_name() -> &'static str {
+        StorageKind::Temporary.name()
+    }
+
+    /// Returns the accessor TokenStream for Instance storage kind.
+    pub fn storage_kind_instance_accessor() -> TokenStream {
+        StorageKind::Instance.accessor()
+    }
+
+    /// Returns the accessor TokenStream for Persistent storage kind.
+    pub fn storage_kind_persistent_accessor() -> TokenStream {
+        StorageKind::Persistent.accessor()
+    }
+
+    /// Returns the accessor TokenStream for Temporary storage kind.
+    pub fn storage_kind_temporary_accessor() -> TokenStream {
+        StorageKind::Temporary.accessor()
+    }
+
+    // ========================================================================
+    // VariantConfig wrapper functions
+    // ========================================================================
+
+    /// Gets VariantConfig info from a Variant.
+    pub fn get_variant_config_for_test(variant: &Variant) -> Result<VariantConfigInfo, String> {
+        VariantConfig::try_from(variant).map(|c| {
+            let value_type = c.value_type;
+            VariantConfigInfo {
+                name: c.name,
+                kind_name: c.kind.name().to_string(),
+                value_type: quote!(#value_type).to_string(),
+                has_default: c.default_value.is_some(),
+                auto_ttl: c.auto_ttl,
+            }
+        })
+    }
+
+    /// Gets method names from a Variant as strings.
+    pub fn get_variant_method_names_for_test(
+        variant: &Variant,
+    ) -> Result<(String, String, String, String, String, String), String> {
+        VariantConfig::try_from(variant).map(|c| {
+            let (getter, setter, remover, set_or_remove, has, ttl_extender) = c.method_names();
+            (
+                getter.to_string(),
+                setter.to_string(),
+                remover.to_string(),
+                set_or_remove.to_string(),
+                has.to_string(),
+                ttl_extender.to_string(),
+            )
+        })
+    }
+
+    // ========================================================================
+    // parse_storage_type wrapper - returns kind name instead of enum
+    // ========================================================================
+
+    /// Test-only wrapper for parse_storage_type that returns kind name as string.
+    pub fn parse_storage_type_for_test(attrs: &[Attribute]) -> Result<(String, Type), String> {
+        parse_storage_type(attrs).map(|(kind, ty)| (kind.name().to_string(), ty))
+    }
+
+    // ========================================================================
+    // Other wrapper functions
+    // ========================================================================
+
+    /// Test-only wrapper for is_primitive_type.
+    pub fn is_primitive_type_for_test(ty: &Type) -> bool {
+        is_primitive_type(ty)
+    }
+
+    /// Test-only wrapper for extract_fields.
+    pub fn extract_fields_for_test(variant: &Variant) -> Vec<(&Ident, &Type)> {
+        extract_fields(variant)
+    }
+
+    /// Test-only wrapper for gen_params.
+    pub fn gen_params_for_test(variant: &Variant) -> TokenStream {
+        gen_params(variant)
+    }
+
+    /// Test-only wrapper for gen_args.
+    pub fn gen_args_for_test(variant: &Variant) -> TokenStream {
+        gen_args(variant)
+    }
+
+    /// Test-only wrapper for gen_key.
+    pub fn gen_key_for_test(enum_name: &Ident, variant: &Variant) -> TokenStream {
+        gen_key(enum_name, variant)
+    }
+
+    /// Test-only wrapper for gen_enum_variant.
+    pub fn gen_enum_variant_for_test(variant: &Variant) -> TokenStream {
+        gen_enum_variant(variant)
+    }
+
+    /// Test-only wrapper for gen_accessor_methods.
+    pub fn gen_accessor_methods_for_test(enum_name: &Ident, variant: &Variant) -> TokenStream {
+        gen_accessor_methods(enum_name, variant)
+    }
+
+    /// Test-only wrapper for validate_attrs.
+    pub fn validate_attrs_for_test(attrs: &[Attribute], variant_ident: &Ident) -> Result<(), String> {
+        validate_attrs(attrs, variant_ident)
+    }
+
+    /// Test-only wrapper for parse_default.
+    pub fn parse_default_for_test(attrs: &[Attribute]) -> Result<Option<Expr>, String> {
+        parse_default(attrs)
+    }
+
+    /// Test-only wrapper for parse_name.
+    pub fn parse_name_for_test(attrs: &[Attribute]) -> Result<Option<String>, String> {
+        parse_name(attrs)
+    }
+
+    /// Test-only wrapper for parse_no_ttl_extension.
+    pub fn parse_no_ttl_extension_for_test(attrs: &[Attribute]) -> Result<bool, String> {
+        parse_no_ttl_extension(attrs)
+    }
+
+    /// Returns the list of known attributes for testing.
+    pub fn known_attrs_for_test() -> &'static [&'static str] {
+        KNOWN_ATTRS
+    }
 }

package/contracts/common-macros/src/tests/auth.rs

@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 
-use crate::tests::test_helpers::{assert_panics_contains, non_struct_item_inputs};
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
 
 // ============================================
 // Snapshot Test: Ownable Code Generation
@@ -15,11 +15,29 @@ fn snapshot_generated_ownable_code() {
     let result = crate::auth::generate_ownable_impl(input);
     let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
 
-    insta::assert_snapshot!(formatted);
+    let input = quote! {
+        #[derive(Clone, Debug)]
+        pub struct MyContract<T>
+        where
+            T: Clone,
+        {
+            pub value: T,
+        }
+    };
+    let result = crate::auth::generate_ownable_impl(input);
+    let formatted_with_generics_and_fields =
+        prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    let combined = format!(
+        "// === Unit struct ===\n\n{}\n\n// === Generics + fields ===\n\n{}",
+        formatted, formatted_with_generics_and_fields
+    );
+
+    insta::assert_snapshot!(combined);
 }
 
 // ============================================
-// Snapshot Test: Multisig Code Generation
+// Snapshot Test: MultiSig Code Generation
 // ============================================
 
 #[test]
@@ -30,7 +48,20 @@ fn snapshot_generated_multisig_code() {
     let result = crate::auth::generate_multisig_impl(input);
     let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
 
-    insta::assert_snapshot!(formatted);
+    let input = quote! {
+        #[derive(Copy, Clone)]
+        pub struct MyContract(pub u32);
+    };
+    let result = crate::auth::generate_multisig_impl(input);
+    let formatted_with_tuple_struct =
+        prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    let combined = format!(
+        "// === Unit struct ===\n\n{}\n\n// === Tuple struct ===\n\n{}",
+        formatted, formatted_with_tuple_struct
+    );
+
+    insta::assert_snapshot!(combined);
 }
 
 // ============================================
@@ -98,13 +129,33 @@ fn test_only_auth_inserts_correct_code_at_the_beginning() {
     let test_cases = vec![
         ("Env by value", quote! { pub fn f(my_custom_env: Env) {} }, "&my_custom_env"),
         ("Env not first param (ref)", quote! { pub fn f(x: u32, my_custom_env: &Env) {} }, "my_custom_env"),
+        ("Env after receiver", quote! { pub fn f(&self, my_custom_env: &Env) {} }, "my_custom_env"),
+        ("Env after mut receiver", quote! { pub fn f(&mut self, my_custom_env: &Env) {} }, "my_custom_env"),
+        ("Env after value receiver", quote! { pub fn f(self, my_custom_env: &Env) {} }, "my_custom_env"),
+        ("Env after mut value receiver", quote! { pub fn f(mut self, my_custom_env: &Env) {} }, "my_custom_env"),
+        ("Env with lifetime", quote! { pub fn f<'a>(my_custom_env: &'a Env) {} }, "my_custom_env"),
+        ("Env with mut ref", quote! { pub fn f(my_custom_env: &mut Env) {} }, "my_custom_env"),
+        ("Env with mut binding", quote! { pub fn f(mut my_custom_env: Env) {} }, "&my_custom_env"),
+        ("Ref Env with mut binding", quote! { pub fn f(mut my_custom_env: &Env) {} }, "my_custom_env"),
         (
             "Qualified path (soroban_sdk::Env)",
             quote! { pub fn f(my_custom_env: soroban_sdk::Env) {} },
             "&my_custom_env",
         ),
         ("Reference to qualified path", quote! { pub fn f(my_custom_env: &soroban_sdk::Env) {} }, "my_custom_env"),
+        (
+            "Leading :: qualified path (::soroban_sdk::Env)",
+            quote! { pub fn f(my_custom_env: ::soroban_sdk::Env) {} },
+            "&my_custom_env",
+        ),
+        ("Leading :: ref qualified path", quote! { pub fn f(my_custom_env: &::soroban_sdk::Env) {} }, "my_custom_env"),
+        (
+            "Mut reference to qualified path",
+            quote! { pub fn f(my_custom_env: &mut soroban_sdk::Env) {} },
+            "my_custom_env",
+        ),
         ("Nested reference (&&Env)", quote! { pub fn f(my_custom_env: &&Env) {} }, "my_custom_env"),
+        ("Multiple Env params picks first", quote! { pub fn f(first_env: Env, second_env: Env) {} }, "&first_env"),
     ];
 
     for (description, input, expected_env_ref) in test_cases {
@@ -125,6 +176,11 @@ fn test_only_auth_requires_env_param() {
         ("wildcard pattern", quote! { pub fn admin_action(_: &Env) {} }),
         // Struct destructuring pattern is not supported
         ("struct pattern", quote! { pub fn admin_action(Env { .. }: Env) {} }),
+        // Non-Env wrapper/container types are not recognized as Env params.
+        ("Option<Env>", quote! { pub fn admin_action(env: Option<Env>) {} }),
+        ("Option<&Env>", quote! { pub fn admin_action(env: Option<&Env>) {} }),
+        ("Vec<Env>", quote! { pub fn admin_action(env: Vec<Env>) {} }),
+        ("Box<Env>", quote! { pub fn admin_action(env: Box<Env>) {} }),
     ];
 
     for (case, input) in cases {
@@ -134,13 +190,26 @@ fn test_only_auth_requires_env_param() {
     }
 }
 
+// ============================================
+// Error Cases: only_auth macro non-function input
+// ============================================
+
+#[test]
+fn test_only_auth_rejects_non_function_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["function"]) {
+        assert_panics_contains(case, "failed to parse function", || {
+            crate::auth::prepend_only_auth_check(input.clone());
+        });
+    }
+}
+
 // ============================================
 // Error Cases: ownable macro non-struct input
 // ============================================
 
 #[test]
 fn test_ownable_rejects_non_struct_inputs() {
-    for (case, input) in non_struct_item_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["struct"]) {
         assert_panics_contains(case, "failed to parse struct", || {
             crate::auth::generate_ownable_impl(input.clone());
         });
@@ -153,7 +222,7 @@ fn test_ownable_rejects_non_struct_inputs() {
 
 #[test]
 fn test_multisig_rejects_non_struct_inputs() {
-    for (case, input) in non_struct_item_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["struct"]) {
         assert_panics_contains(case, "failed to parse struct", || {
             crate::auth::generate_multisig_impl(input.clone());
         });