@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.12

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

@@ -0,0 +1,168 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, non_enum_item_inputs};
+
+// ============================================
+// Error Cases: Invalid Inputs
+// ============================================
+
+#[test]
+fn test_contract_error_rejects_non_enum_inputs() {
+    for (case, input) in non_enum_item_inputs() {
+        assert_panics_contains(case, "failed to parse enum", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_rejects_attr_arguments() {
+    let input = quote! {
+        pub enum MyError {
+            A,
+        }
+    };
+    assert_panics_contains("attr not empty", "contract_error attribute is not supported", || {
+        crate::error::generate_error(quote! { some_attr }, input);
+    });
+}
+
+#[test]
+fn test_contract_error_requires_unit_variants() {
+    let cases = vec![("tuple variant", quote! { A(u32) }), ("struct variant", quote! { A { x: u32 } })];
+
+    for (case, variant) in cases {
+        let input = quote! {
+            pub enum MyError {
+                #variant,
+            }
+        };
+        assert_panics_contains(case, "Error enum variants must be unit variants", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_discriminant_must_be_integer_literal() {
+    let cases = vec![
+        ("binary expr", quote! { 1 + 1 }),
+        ("path expr", quote! { SOME_CONST }),
+        ("negative integer (unary expr)", quote! { -1 }),
+        ("paren expr", quote! { (1) }),
+        ("bool literal", quote! { true }),
+        ("string literal", quote! { "1" }),
+        ("float literal", quote! { 1.0 }),
+        ("char literal", quote! { 'a' }),
+    ];
+
+    for (case, expr) in cases {
+        let input = quote! {
+            pub enum MyError {
+                A = #expr,
+            }
+        };
+        assert_panics_contains(case, "Error enum discriminant must be an integer literal", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_discriminant_must_fit_u32() {
+    let input = quote! {
+        pub enum MyError {
+            A = 4294967296,
+        }
+    };
+
+    assert_panics_contains("u32::MAX + 1", "Error enum discriminant must be a valid u32 integer", || {
+        crate::error::generate_error(quote! {}, input);
+    });
+}
+
+#[test]
+fn test_contract_error_discriminants_ordering_rejections_table_driven() {
+    let cases = vec![
+        (
+            "explicit value is less than previous",
+            quote! {
+                // A is assigned 1 by default; B cannot go backwards.
+                A,
+                B = 1,
+            },
+        ),
+        (
+            "explicit zero",
+            quote! {
+                A = 0,
+            },
+        ),
+        (
+            "explicit equal to previous explicit",
+            quote! {
+                A = 1,
+                B = 1,
+            },
+        ),
+        (
+            "explicit decreases after explicit",
+            quote! {
+                A = 5,
+                B = 4,
+            },
+        ),
+    ];
+
+    for (case, variants) in cases {
+        let input = quote! {
+            pub enum MyError {
+                #variants
+            }
+        };
+        assert_panics_contains(case, "Error enum discriminant must be greater than the previous discriminant", || {
+            crate::error::generate_error(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contract_error_max_not_last_panics_overflow() {
+    let input = quote! {
+        pub enum MyError {
+            A = 4294967295,
+            B,
+        }
+    };
+    assert_panics_contains("max not last overflows", "attempt to add with overflow", || {
+        crate::error::generate_error(quote! {}, input);
+    });
+}
+
+// ============================================
+// Valid Cases: Snapshot Tests for Generated Code
+// ============================================
+
+#[test]
+fn snapshot_generated_contract_error_code() {
+    let input = quote! {
+        /// Example error enum
+        pub enum MyError {
+            /// Implicit (should start at 1)
+            A,
+            /// Implicit (should be 2)
+            B,
+            /// Explicit (must be >= previous + 1)
+            C = 10,
+            /// Implicit (should be 11)
+            D,
+            /// Explicit max boundary (u32::MAX)
+            E = 4294967295,
+        }
+    };
+
+    let result = crate::error::generate_error(quote! {}, input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}

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

@@ -1,9 +1,7 @@
 mod contract_impl;
+mod error;
 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).
+mod utils;

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

@@ -19,15 +19,33 @@ fn snapshot_generated_ownable_code() {
 
 #[test]
 fn snapshot_only_owner_preserves_function_signature() {
-    let input = quote! {
+    // Test with borrowed Env (&Env) - should use env directly
+    let input_borrowed = quote! {
         pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Error> {
             Ok(value.clone())
         }
     };
-    let result = crate::ownable::prepend_only_owner_check(input);
-    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+    let result_borrowed = crate::ownable::prepend_only_owner_check(input_borrowed);
+    let formatted_borrowed =
+        prettyplease::unparse(&syn::parse2::<syn::File>(result_borrowed).expect("failed to parse generated code"));
 
-    insta::assert_snapshot!(formatted);
+    // Test with owned Env - should produce &env reference in the generated code
+    let input_owned = quote! {
+        pub(crate) async fn admin_action<T: Clone>(env: Env, value: T) -> Result<T, Error> {
+            Ok(value.clone())
+        }
+    };
+    let result_owned = crate::ownable::prepend_only_owner_check(input_owned);
+    let formatted_owned =
+        prettyplease::unparse(&syn::parse2::<syn::File>(result_owned).expect("failed to parse generated code"));
+
+    // Combine all for single snapshot
+    let combined = format!(
+        "// === Borrowed Env (&Env) ===\n\n{}\n\n// === Owned Env (Env) ===\n\n{}",
+        formatted_borrowed, formatted_owned
+    );
+
+    insta::assert_snapshot!(combined);
 }
 
 // ============================================
@@ -35,7 +53,7 @@ fn snapshot_only_owner_preserves_function_signature() {
 // ============================================
 
 /// Helper function to verify that the owner check is correctly inserted at the beginning of a function.
-fn assert_owner_check_inserted(input: TokenStream, test_name: &str) {
+fn assert_owner_check_inserted(input: TokenStream, expected_env_ref: &str, test_name: &str) {
     let result_tokens = crate::ownable::prepend_only_owner_check(input);
     let output_fn: syn::ItemFn =
         syn::parse2(result_tokens).unwrap_or_else(|e| panic!("{}: failed to parse output function: {}", test_name, e));
@@ -43,7 +61,7 @@ fn assert_owner_check_inserted(input: TokenStream, test_name: &str) {
     assert!(!output_fn.block.stmts.is_empty(), "{}: function body should contain at least one statement", test_name);
 
     let first_stmt = &output_fn.block.stmts[0];
-    let expected_stmt = "utils::ownable::require_owner_auth::<Self>(my_custom_env);";
+    let expected_stmt = format!("utils::ownable::require_owner_auth::<Self>({});", expected_env_ref);
     let actual_stmt = quote::quote!(#first_stmt).to_string().replace(" ", "");
 
     assert_eq!(
@@ -55,15 +73,22 @@ fn assert_owner_check_inserted(input: TokenStream, test_name: &str) {
 
 #[test]
 fn test_only_owner_inserts_correct_code_at_the_beginning() {
+    // (description, input, expected_env_ref)
+    // Owned Env should produce &env, reference Env should produce env directly
     let test_cases = vec![
-        ("Env by value", quote! { pub fn f(my_custom_env: Env) {} }),
-        ("Env not first param", quote! { pub fn f(x: u32, my_custom_env: &Env) {} }),
-        ("Qualified path (soroban_sdk::Env)", quote! { pub fn f(my_custom_env: soroban_sdk::Env) {} }),
-        ("Nested reference (&&Env)", quote! { pub fn f(my_custom_env: &&Env) {} }),
+        ("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"),
+        (
+            "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"),
+        ("Nested reference (&&Env)", quote! { pub fn f(my_custom_env: &&Env) {} }, "my_custom_env"),
     ];
 
-    for (description, input) in test_cases {
-        assert_owner_check_inserted(input, description);
+    for (description, input, expected_env_ref) in test_cases {
+        assert_owner_check_inserted(input, expected_env_ref, description);
     }
 }
 
@@ -101,51 +126,3 @@ fn test_ownable_rejects_non_struct_inputs() {
         });
     }
 }
-
-// ============================================
-// is_env_type Unit Tests
-// ============================================
-
-#[test]
-fn test_is_env_type_recognizes_env_types() {
-    let env_types = [
-        "Env",
-        "&Env",
-        "&&Env",
-        "&mut Env",
-        "soroban_sdk::Env",
-        "&soroban_sdk::Env",
-        "some::deeply::nested::module::Env",
-    ];
-
-    for ty_str in env_types {
-        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
-        assert!(crate::utils::is_env_type(&ty), "{ty_str} should be recognized as an Env type");
-    }
-}
-
-#[test]
-fn test_is_env_type_rejects_non_env_types() {
-    let non_env_types = ["u32", "bool", "String", "Address", "&u32", "soroban_sdk::Address"];
-
-    for ty_str in non_env_types {
-        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
-        assert!(!crate::utils::is_env_type(&ty), "{ty_str} should NOT be recognized as an Env type");
-    }
-}
-
-#[test]
-fn test_is_env_type_rejects_other_type_variants() {
-    let other_variants = [
-        ("(Env, u32)", "tuple"),
-        ("[Env; 1]", "array"),
-        ("[Env]", "slice"),
-        ("Option<Env>", "generic"),
-        ("!", "never"),
-    ];
-
-    for (ty_str, label) in other_variants {
-        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
-        assert!(!crate::utils::is_env_type(&ty), "{label} type {ty_str} should NOT be recognized as an Env type");
-    }
-}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__contract_impl__snapshot_generated_contract_impl_code.snap

@@ -1,6 +1,6 @@
 ---
 source: contracts/common-macros/src/tests/contract_impl.rs
-assertion_line: 98
+assertion_line: 104
 expression: combined
 ---
 // === Inherent Impl (no attr) ===
@@ -9,7 +9,7 @@ expression: combined
 impl MyContract {
     /// Public method with Env - should have TTL extension
     pub fn public_with_env(env: Env, value: u32) -> u32 {
-        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(&env) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -18,7 +18,7 @@ impl MyContract {
     }
     /// Public method with qualified Env path - should have TTL extension
     pub fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
-        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(&env) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -26,7 +26,7 @@ impl MyContract {
         42
     }
     /// Public method with Env not as first parameter - should have TTL extension
-    pub fn env_second(value: u32, env: Env) -> u32 {
+    pub fn env_second(value: u32, env: &Env) -> u32 {
         if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
             env.storage()
                 .instance()
@@ -55,7 +55,7 @@ impl MyContract {
 impl SomeTrait for MyContract {
     /// Trait method with Env - should have TTL extension
     fn trait_method_with_env(env: Env, value: u32) -> u32 {
-        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(&env) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -66,6 +66,16 @@ impl SomeTrait for MyContract {
     fn trait_method_without_env(value: u32) -> u32 {
         value * 4
     }
+    /// Trait method with macro attribute - should have TTL extension
+    #[common_macros::only_owner]
+    fn trait_method_with_only_owner_attribute(env: Env, value: u32) -> u32 {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(&env) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 5
+    }
 }
 
 
@@ -74,7 +84,7 @@ impl SomeTrait for MyContract {
 #[soroban_sdk::contractimpl(contracttrait)]
 impl AnotherTrait for MyContract {
     /// Trait method with contracttrait attr - should have TTL extension
-    fn contracttrait_method(env: Env, value: u32) -> u32 {
+    fn contracttrait_method(env: &Env, value: u32) -> u32 {
         if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
             env.storage()
                 .instance()

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__error__snapshot_generated_contract_error_code.snap

@@ -0,0 +1,20 @@
+---
+source: contracts/common-macros/src/tests/error.rs
+expression: formatted
+---
+#[soroban_sdk::contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+#[repr(u32)]
+/// Example error enum
+pub enum MyError {
+    /// Implicit (should start at 1)
+    A = 1u32,
+    /// Implicit (should be 2)
+    B = 2u32,
+    /// Explicit (must be >= previous + 1)
+    C = 10,
+    /// Implicit (should be 11)
+    D = 11u32,
+    /// Explicit max boundary (u32::MAX)
+    E = 4294967295,
+}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__ownable__snapshot_generated_ownable_code.snap

@@ -16,14 +16,16 @@ impl utils::ownable::OwnableInitializer for MyContract {
     }
 }
 /// Implement the Ownable trait for the contract.
-#[soroban_sdk::contractimpl]
+#[common_macros::contract_impl]
 impl utils::ownable::Ownable for MyContract {
     fn owner(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
         utils::ownable::DefaultOwnable::owner(env)
     }
+    #[common_macros::only_owner]
     fn transfer_ownership(env: &soroban_sdk::Env, new_owner: &soroban_sdk::Address) {
         utils::ownable::DefaultOwnable::transfer_ownership(env, new_owner)
     }
+    #[common_macros::only_owner]
     fn renounce_ownership(env: &soroban_sdk::Env) {
         utils::ownable::DefaultOwnable::renounce_ownership(env)
     }

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__ownable__snapshot_only_owner_preserves_function_signature.snap

@@ -1,9 +1,19 @@
 ---
 source: contracts/common-macros/src/tests/ownable.rs
-assertion_line: 28
-expression: formatted
+assertion_line: 48
+expression: combined
 ---
+// === Borrowed Env (&Env) ===
+
 pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Error> {
     utils::ownable::require_owner_auth::<Self>(env);
     Ok(value.clone())
 }
+
+
+// === Owned Env (Env) ===
+
+pub(crate) async fn admin_action<T: Clone>(env: Env, value: T) -> Result<T, Error> {
+    utils::ownable::require_owner_auth::<Self>(&env);
+    Ok(value.clone())
+}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__ttl_configurable__snapshot_generated_ttl_configurable_code.snap

@@ -8,7 +8,7 @@ pub struct MyContract {
     some_field: u32,
 }
 use utils::ttl::TtlConfigurable as _;
-#[soroban_sdk::contractimpl]
+#[common_macros::contract_impl]
 impl utils::ttl::TtlConfigurable for MyContract {
     #[common_macros::only_owner]
     fn set_ttl_configs(
@@ -31,6 +31,10 @@ impl utils::ttl::TtlConfigurable for MyContract {
         utils::ttl::DefaultTtlConfigurable::is_ttl_configs_frozen(env)
     }
 }
+/// Uses `soroban_sdk::contractimpl` directly instead of `common_macros::contract_impl`
+/// because `contract_impl` automatically extends TTL on every invocation. Since this
+/// impl block provides manual TTL extension control, auto-extension would be redundant
+/// and could mask the intended behavior of `extend_instance_ttl`.
 #[soroban_sdk::contractimpl]
 impl MyContract {
     /// Extends the instance TTL.