@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

@@ -6,35 +6,12 @@ use heck::ToSnakeCase;
 use itertools::Itertools;
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
-use syn::{
-    parse::{Parse, ParseStream},
-    Expr, Fields, FieldsNamed, Meta, Result, Type, TypePath, Variant,
-};
+use syn::{Expr, Fields, FieldsNamed, Type, Variant};
 
 // ============================================================================
 // Types & Parsing
 // ============================================================================
 
-/// TTL provider configuration for auto-extending storage TTL.
-/// Parsed from `#[storage(MyTtlProvider)]` attribute.
-#[derive(Debug, Clone)]
-struct TtlProvider(Option<Type>);
-
-impl Parse for TtlProvider {
-    fn parse(input: ParseStream) -> Result<Self> {
-        if input.is_empty() {
-            return Ok(Self(None));
-        }
-
-        let meta: Meta = input.parse()?;
-        let Meta::Path(path) = meta else {
-            return Err(syn::Error::new(input.span(), "TTL provider must be a path"));
-        };
-
-        Ok(Self(Some(Type::Path(TypePath { qself: None, path }))))
-    }
-}
-
 /// Storage type parsed from `#[instance(Type)]`, `#[persistent(Type)]`, or `#[temporary(Type)]`.
 #[derive(Debug, Clone)]
 enum StorageType {
@@ -54,6 +31,10 @@ impl StorageType {
         matches!(self, Self::Instance(_))
     }
 
+    fn is_persistent(&self) -> bool {
+        matches!(self, Self::Persistent(_))
+    }
+
     /// Returns the storage accessor method name.
     fn accessor_name(&self) -> &'static str {
         match self {
@@ -86,7 +67,7 @@ pub(crate) struct StorageVariantConfig {
     name: String,
     storage_type: StorageType,
     default_value: Option<Expr>,
-    no_auto_ttl_extension: bool,
+    no_ttl_extension: bool,
 }
 
 impl StorageVariantConfig {
@@ -98,7 +79,7 @@ impl StorageVariantConfig {
             setter: format_ident!("set_{}", base),
             remover: format_ident!("remove_{}", base),
             set_or_remove: format_ident!("set_or_remove_{}", base),
-            ttl_extender: format_ident!("extend_ttl_{}", base),
+            ttl_extender: format_ident!("extend_{}_ttl", base),
             has: format_ident!("has_{}", base),
         }
     }
@@ -112,7 +93,7 @@ impl TryFrom<&Variant> for StorageVariantConfig {
 
         // Known attribute identifiers for this macro ("doc" allows /// comments on variants)
         const KNOWN_ATTRS: &[&str] =
-            &["doc", "instance", "persistent", "temporary", "default", "no_auto_ttl_extension", "name"];
+            &["doc", "instance", "persistent", "temporary", "default", "name", "no_ttl_extension"];
 
         // Check for unsupported attributes
         if let Some(unknown) = attrs
@@ -148,18 +129,6 @@ impl TryFrom<&Variant> for StorageVariantConfig {
             .transpose()
             .map_err(|e| format!("failed to parse default value: {}", e))?;
 
-        // Check for no_auto_ttl_extension flag
-        let no_auto_ttl_extension = attrs
-            .iter()
-            .filter(|attr| attr.path().is_ident("no_auto_ttl_extension"))
-            .map(|attr| {
-                attr.meta.require_path_only().map_err(|_| "no_auto_ttl_extension does not accept arguments".to_string())
-            })
-            .at_most_one()
-            .map_err(|_| "multiple no_auto_ttl_extension attributes specified")?
-            .transpose()?
-            .is_some();
-
         // Parse optional name override for storage key generation
         // If no #[name("custom_name")] attribute is provided, defaults to snake_case of variant name
         let name = attrs
@@ -172,7 +141,18 @@ impl TryFrom<&Variant> for StorageVariantConfig {
             .map_err(|e| format!("failed to parse name attribute: {}", e))?
             .unwrap_or_else(|| variant.ident.to_string().to_snake_case());
 
-        Ok(Self { storage_type, default_value, no_auto_ttl_extension, name })
+        // Parse optional #[no_ttl_extension] to skip automatic TTL extension (persistent only)
+        let no_ttl_extension = attrs
+            .iter()
+            .filter(|attr| attr.path().is_ident("no_ttl_extension"))
+            .at_most_one()
+            .map_err(|_| "multiple #[no_ttl_extension] attributes specified")?
+            .is_some();
+        if no_ttl_extension && !storage_type.is_persistent() {
+            return Err("#[no_ttl_extension] can only be used with #[persistent(...)] storage".to_string());
+        }
+
+        Ok(Self { storage_type, default_value, name, no_ttl_extension })
     }
 }
 
@@ -193,17 +173,18 @@ struct FunctionNames {
 /// Generates the storage API from the `#[storage]` attribute macro.
 pub(crate) fn generate_storage(attr: TokenStream, input: TokenStream) -> TokenStream {
     let item_enum: syn::ItemEnum = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse enum: {}", e));
-    let ttl_provider: TtlProvider = syn::parse2(attr).unwrap_or_else(|e| panic!("failed to parse attribute: {}", e));
+
+    // Ensure no arguments are passed to #[storage]
+    if !attr.is_empty() {
+        panic!("the #[storage] attribute does not accept arguments");
+    }
 
     let enum_name = &item_enum.ident;
     let contracttype_variants: Vec<_> = item_enum.variants.iter().map(gen_contracttype_variant).collect();
-    let inherent_impls: Vec<_> =
-        item_enum.variants.iter().map(|v| gen_storage_functions(enum_name, v, &ttl_provider)).collect();
+    let inherent_impls: Vec<_> = item_enum.variants.iter().map(|v| gen_storage_functions(enum_name, v)).collect();
 
     let visibility = &item_enum.vis;
     quote! {
-        use utils::ttl::TtlConfigProvider as _;
-
         #[soroban_sdk::contracttype]
         #visibility enum #enum_name {
             #(#contracttype_variants,)*
@@ -229,7 +210,7 @@ fn gen_contracttype_variant(variant: &Variant) -> TokenStream {
 }
 
 /// Generates all storage accessor functions for a variant.
-fn gen_storage_functions(enum_name: &Ident, variant: &Variant, ttl_provider: &TtlProvider) -> TokenStream {
+fn gen_storage_functions(enum_name: &Ident, variant: &Variant) -> TokenStream {
     let config = StorageVariantConfig::try_from(variant)
         .unwrap_or_else(|e| panic!("failed to parse storage variant for {}: {}", variant.ident, e));
 
@@ -241,19 +222,36 @@ fn gen_storage_functions(enum_name: &Ident, variant: &Variant, ttl_provider: &Tt
     let storage_acc = gen_storage_accessor(&config.storage_type);
     let value_type = config.storage_type.value_type();
 
-    // Auto TTL extension (if provider exists and not disabled)
-    let auto_ttl = ttl_provider
-        .0
-        .as_ref()
-        .filter(|_| !config.no_auto_ttl_extension)
-        .map(|p| gen_ttl_extension(&config.storage_type, Some(p)))
-        .unwrap_or_default();
+    // Automatic TTL extension for persistent storage (unless #[no_ttl_extension] is specified)
+    let auto_ttl_extend = if config.storage_type.is_persistent() && !config.no_ttl_extension {
+        gen_ttl_extension(&config.storage_type, true)
+    } else {
+        TokenStream::new()
+    };
 
-    let getter_impl =
-        gen_getter_fn(&getter, &fn_params, &storage_key, &storage_acc, value_type, &config.default_value, &auto_ttl);
+    let getter_impl = gen_getter_fn(
+        &getter,
+        &fn_params,
+        &storage_key,
+        &storage_acc,
+        value_type,
+        &config.default_value,
+        &auto_ttl_extend,
+    );
 
     // Manual TTL extension (user provides threshold/extend_to)
-    let manual_ttl = gen_ttl_extension(&config.storage_type, None);
+    let manual_ttl_extend = gen_ttl_extension(&config.storage_type, false);
+
+    // Has implementation (conditionally includes TTL extension)
+    let has_impl = if auto_ttl_extend.is_empty() {
+        quote! { #storage_acc.has(&key) }
+    } else {
+        quote! {
+            let exists = #storage_acc.has(&key);
+            if exists { #auto_ttl_extend }
+            exists
+        }
+    };
 
     quote! {
         #getter_impl
@@ -261,7 +259,7 @@ fn gen_storage_functions(enum_name: &Ident, variant: &Variant, ttl_provider: &Tt
         pub fn #setter(#fn_params, value: &#value_type) {
             let key = #storage_key;
             #storage_acc.set(&key, value);
-            #auto_ttl
+            #auto_ttl_extend
         }
 
         pub fn #remover(#fn_params) {
@@ -278,14 +276,12 @@ fn gen_storage_functions(enum_name: &Ident, variant: &Variant, ttl_provider: &Tt
 
         pub fn #has(#fn_params) -> bool {
             let key = #storage_key;
-            let exists = #storage_acc.has(&key);
-            if exists { #auto_ttl }
-            exists
+            #has_impl
         }
 
         pub fn #ttl_extender(#fn_params, threshold: u32, extend_to: u32) {
             let key = #storage_key;
-            #manual_ttl
+            #manual_ttl_extend
         }
     }
 }
@@ -297,14 +293,9 @@ fn gen_storage_accessor(storage_type: &StorageType) -> TokenStream {
 }
 
 /// Generates TTL extension code.
-/// - With provider: uses provider to get threshold/extend_to
-/// - Without provider (None): uses local variables `threshold` and `extend_to`
-fn gen_ttl_extension(storage_type: &StorageType, provider: Option<&Type>) -> TokenStream {
-    let get_ttl_values = provider.map(|p| {
-        let method = format_ident!("{}", storage_type.accessor_name());
-        quote! { let utils::ttl::TtlConfig { threshold, extend_to } = utils::ttl::ttl_config::#method::<#p>(env); }
-    });
-
+/// - use_stored_config=true: fetches TTL config from TtlConfigStorage, only extends if config is set
+/// - use_stored_config=false: uses local variables `threshold` and `extend_to` (for manual extension)
+fn gen_ttl_extension(storage_type: &StorageType, use_stored_config: bool) -> TokenStream {
     let accessor = gen_storage_accessor(storage_type);
     let extend_call = if storage_type.is_instance() {
         quote! { #accessor.extend_ttl(threshold, extend_to); }
@@ -312,25 +303,24 @@ fn gen_ttl_extension(storage_type: &StorageType, provider: Option<&Type>) -> Tok
         quote! { #accessor.extend_ttl(&key, threshold, extend_to); }
     };
 
-    quote! {
-        #get_ttl_values
-        #extend_call
+    if use_stored_config {
+        let method = format_ident!("{}", storage_type.accessor_name());
+        quote! {
+            if let Some(utils::ttl::TtlConfig { threshold, extend_to }) = utils::ttl::TtlConfigStorage::#method(env) {
+                #extend_call
+            }
+        }
+    } else {
+        extend_call
     }
 }
 
 /// Checks if a type is a primitive type
-fn is_primitive_type(ty: &Type) -> bool {
-    if let Type::Path(type_path) = ty {
-        if type_path.path.segments.len() == 1 {
-            let segment = &type_path.path.segments[0];
-            let ident = &segment.ident;
-            matches!(ident.to_string().as_str(), "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "bool")
-        } else {
-            false
-        }
-    } else {
-        false
-    }
+pub(crate) fn is_primitive_type(ty: &Type) -> bool {
+    let Type::Path(type_path) = ty else { return false };
+    let Some(segment) = type_path.path.segments.first() else { return false };
+    type_path.path.segments.len() == 1
+        && matches!(segment.ident.to_string().as_str(), "u32" | "i32" | "u64" | "i64" | "u128" | "i128" | "bool")
 }
 
 /// Generates function parameters: `env: &Env` or `env: &Env, field1: Type1, ...`.
@@ -398,42 +388,27 @@ fn gen_getter_fn(
     key: &TokenStream,
     accessor: &TokenStream,
     value_type: &Type,
-    has_default: &Option<Expr>,
-    ttl_extend: &TokenStream,
+    default_value: &Option<Expr>,
+    auto_ttl_extend: &TokenStream,
 ) -> TokenStream {
-    let has_ttl = !ttl_extend.is_empty();
-    match (has_default, has_ttl) {
-        // Has default + has TTL extension
-        (Some(default_expr), true) => quote! {
-            pub fn #name(#params) -> #value_type {
-                let key = #key;
-                let value = #accessor.get::<_, #value_type>(&key);
-                if value.is_some() { #ttl_extend }
-                value.unwrap_or(#default_expr)
-            }
-        },
-        // Has default, no TTL extension
-        (Some(default_expr), false) => quote! {
-            pub fn #name(#params) -> #value_type {
-                let key = #key;
-                #accessor.get::<_, #value_type>(&key).unwrap_or(#default_expr)
-            }
-        },
-        // No default + has TTL extension
-        (None, true) => quote! {
-            pub fn #name(#params) -> Option<#value_type> {
-                let key = #key;
-                let value = #accessor.get::<_, #value_type>(&key);
-                if value.is_some() { #ttl_extend }
-                value
-            }
-        },
-        // No default, no TTL extension
-        (None, false) => quote! {
-            pub fn #name(#params) -> Option<#value_type> {
-                let key = #key;
-                #accessor.get::<_, #value_type>(&key)
-            }
-        },
+    let (return_type, return_expr) = match default_value {
+        Some(expr) => (quote! { #value_type }, quote! { value.unwrap_or(#expr) }),
+        None => (quote! { Option<#value_type> }, quote! { value }),
+    };
+
+    // If auto TTL extension is enabled, check if the value is not None and extend the TTL
+    let ttl_check = if auto_ttl_extend.is_empty() {
+        TokenStream::new()
+    } else {
+        quote! { if value.is_some() { #auto_ttl_extend } }
+    };
+
+    quote! {
+        pub fn #name(#params) -> #return_type {
+            let key = #key;
+            let value = #accessor.get::<_, #value_type>(&key);
+            #ttl_check
+            #return_expr
+        }
     }
 }

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

@@ -0,0 +1,289 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::tests::test_helpers::assert_panics_contains;
+
+// ============================================
+// Snapshot Test: ContractImpl Code Generation
+// ============================================
+
+/// Comprehensive snapshot test covering all contract_impl macro features:
+/// - Inherent impl: public methods with Env (adds TTL), private/pub(crate) methods (skipped)
+/// - Trait impl: all methods with Env get TTL extension
+/// - Qualified Env types (soroban_sdk::Env)
+/// - Env parameter not in first position
+/// - Methods without Env (skipped)
+#[test]
+fn snapshot_generated_contract_impl_code() {
+    // Test inherent impl with empty attr
+    let empty_attr = TokenStream::new();
+    let inherent_input = quote! {
+        impl MyContract {
+            /// Public method with Env - should have TTL extension
+            pub fn public_with_env(env: Env, value: u32) -> u32 {
+                value * 2
+            }
+
+            /// Public method with qualified Env path - should have TTL extension
+            pub fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
+                42
+            }
+
+            /// Public method with Env not as first parameter - should have TTL extension
+            pub fn env_second(value: u32, env: Env) -> u32 {
+                value * 2
+            }
+
+            /// Public method without Env - should NOT have TTL extension
+            pub fn public_without_env(value: u32) -> u32 {
+                value * 4
+            }
+
+            /// Private method with Env - should NOT have TTL extension (not public)
+            fn private_with_env(env: Env, value: u32) -> u32 {
+                value * 5
+            }
+
+            /// Pub(crate) method with Env - should NOT have TTL extension (not fully public)
+            pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
+                value * 7
+            }
+        }
+    };
+
+    let inherent_result = crate::contract_impl::contract_impl(empty_attr.clone(), inherent_input);
+    let inherent_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(inherent_result).expect("failed to parse generated code"));
+
+    // Test trait impl with empty attr
+    let trait_input = quote! {
+        impl SomeTrait for MyContract {
+            /// Trait method with Env - should have TTL extension
+            fn trait_method_with_env(env: Env, value: u32) -> u32 {
+                value * 2
+            }
+
+            /// Trait method without Env - should NOT have TTL extension
+            fn trait_method_without_env(value: u32) -> u32 {
+                value * 4
+            }
+        }
+    };
+
+    let trait_result = crate::contract_impl::contract_impl(empty_attr, trait_input);
+    let trait_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(trait_result).expect("failed to parse generated code"));
+
+    // Test trait impl with contracttrait attr
+    let contracttrait_attr = quote! { contracttrait };
+    let contracttrait_input = quote! {
+        impl AnotherTrait for MyContract {
+            /// Trait method with contracttrait attr - should have TTL extension
+            fn contracttrait_method(env: Env, value: u32) -> u32 {
+                value * 3
+            }
+        }
+    };
+
+    let contracttrait_result = crate::contract_impl::contract_impl(contracttrait_attr, contracttrait_input);
+    let contracttrait_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(contracttrait_result).expect("failed to parse generated code"));
+
+    // Combine all for single snapshot
+    let combined = format!(
+        "// === Inherent Impl (no attr) ===\n\n{}\n\n// === Trait Impl (no attr) ===\n\n{}\n\n// === Trait Impl (contracttrait attr) ===\n\n{}",
+        inherent_formatted, trait_formatted, contracttrait_formatted
+    );
+
+    insta::assert_snapshot!(combined);
+}
+
+// ============================================
+// Error Cases: Invalid Input
+// ============================================
+
+#[test]
+fn test_non_impl_block_input() {
+    let invalid_inputs = vec![
+        (
+            "struct",
+            quote! {
+                struct MyStruct {
+                    field: u32,
+                }
+            },
+        ),
+        (
+            "enum",
+            quote! {
+                enum MyEnum {
+                    Variant1,
+                    Variant2,
+                }
+            },
+        ),
+        ("function", quote! { fn a_function() {} }),
+        ("const item", quote! { const A_CONST: u32 = 1; }),
+        ("type alias", quote! { type AnAlias = u32; }),
+        (
+            "trait",
+            quote! {
+                trait ATrait {
+                    fn method(&self);
+                }
+            },
+        ),
+    ];
+
+    for (case, input) in invalid_inputs {
+        assert_panics_contains(case, "failed to parse impl block", || {
+            crate::contract_impl::contract_impl(TokenStream::new(), input.clone());
+        });
+    }
+}
+
+// ============================================
+// Unit Tests: Behavior Verification
+// ============================================
+
+/// Verifies that the macro adds #[soroban_sdk::contractimpl] attribute without parentheses when attr is empty
+#[test]
+fn test_adds_soroban_contractimpl_attribute_without_attr() {
+    let input = quote! {
+        impl MyContract {
+            pub fn my_method(env: Env) {}
+        }
+    };
+
+    let result = crate::contract_impl::contract_impl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    // Should have contractimpl without parentheses when attr is empty
+    assert!(
+        result_str.contains("# [soroban_sdk :: contractimpl]"),
+        "should add #[soroban_sdk::contractimpl] attribute without parentheses when attr is empty. Got: {}",
+        result_str
+    );
+    // Should NOT have empty parentheses
+    assert!(
+        !result_str.contains("contractimpl ()"),
+        "should NOT have empty parentheses when attr is empty. Got: {}",
+        result_str
+    );
+}
+
+/// Verifies that the macro adds #[soroban_sdk::contractimpl(attr)] when attr is provided
+#[test]
+fn test_adds_soroban_contractimpl_attribute_with_attr() {
+    let input = quote! {
+        impl SomeTrait for MyContract {
+            fn my_method(env: Env) {}
+        }
+    };
+
+    let attr = quote! { contracttrait };
+    let result = crate::contract_impl::contract_impl(attr, input);
+    let result_str = result.to_string();
+
+    // Should have contractimpl with the attr in parentheses
+    assert!(
+        result_str.contains("contractimpl (contracttrait)"),
+        "should add #[soroban_sdk::contractimpl(contracttrait)] attribute. Got: {}",
+        result_str
+    );
+}
+
+/// Helper to assert TTL extension behavior in generated code
+fn assert_ttl_extension(input: TokenStream, expected: bool, env_ident: Option<&str>, case: &str) {
+    let result = crate::contract_impl::contract_impl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    let has_ttl = result_str.contains("TtlConfigStorage :: instance");
+
+    assert_eq!(
+        has_ttl,
+        expected,
+        "{}: TTL extension {} but {}",
+        case,
+        if expected { "expected" } else { "not expected" },
+        if has_ttl { "was found" } else { "was not found" }
+    );
+
+    if expected {
+        assert!(result_str.contains("extend_ttl"), "{}: should insert extend_ttl call", case);
+
+        // Verify correct env identifier is used in TTL extension code
+        if let Some(env) = env_ident {
+            let instance_pattern = format!("TtlConfigStorage :: instance ({})", env);
+            let storage_pattern = format!("{} . storage ()", env);
+            assert!(
+                result_str.contains(&instance_pattern),
+                "{}: should use '{}' in TtlConfigStorage::instance call",
+                case,
+                env
+            );
+            assert!(result_str.contains(&storage_pattern), "{}: should use '{}' for storage access", case, env);
+        }
+    }
+}
+
+#[test]
+fn test_ttl_extension_insertion() {
+    let cases: Vec<(&str, TokenStream, bool, Option<&str>)> = vec![
+        // (case name, input, should have TTL extension, optional env ident to verify)
+        (
+            "public method with Env",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(env: Env) { let x = 1; }
+                }
+            },
+            true,
+            Some("env"),
+        ),
+        (
+            "private method with Env",
+            quote! {
+                impl MyContract {
+                    fn private_method(env: Env) { let x = 1; }
+                }
+            },
+            false,
+            None,
+        ),
+        (
+            "public method without Env",
+            quote! {
+                impl MyContract {
+                    pub fn no_env_method(value: u32) -> u32 { value }
+                }
+            },
+            false,
+            None,
+        ),
+        (
+            "custom Env identifier",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(my_custom_env: Env) { let x = 1; }
+                }
+            },
+            true,
+            Some("my_custom_env"),
+        ),
+        (
+            "trait impl method with Env",
+            quote! {
+                impl SomeTrait for MyContract {
+                    fn trait_method(env: Env) { let x = 1; }
+                }
+            },
+            true,
+            Some("env"),
+        ),
+    ];
+
+    for (case, input, expected, env_ident) in cases {
+        assert_ttl_extension(input, expected, env_ident, case);
+    }
+}

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

@@ -0,0 +1,9 @@
+mod contract_impl;
+mod ownable;
+mod storage;
+mod test_helpers;
+mod ttl_configurable;
+
+// Note: error.rs and event.rs use proc_macro::TokenStream which cannot be tested
+// outside of a procedural macro context. These macros are tested via integration
+// tests in the contracts that use them (e.g., utils crate).