@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -1,6 +1,6 @@
 use quote::quote;
 
-use crate::tests::test_helpers::{assert_panics_contains, non_enum_item_inputs};
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
 
 // ============================================
 // Error Cases: Invalid Inputs
@@ -8,25 +8,13 @@ use crate::tests::test_helpers::{assert_panics_contains, non_enum_item_inputs};
 
 #[test]
 fn test_contract_error_rejects_non_enum_inputs() {
-    for (case, input) in non_enum_item_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["enum"]) {
         assert_panics_contains(case, "failed to parse enum", || {
-            crate::error::generate_error(quote! {}, input.clone());
+            crate::error::generate_error(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 } })];
@@ -38,7 +26,7 @@ fn test_contract_error_requires_unit_variants() {
             }
         };
         assert_panics_contains(case, "Error enum variants must be unit variants", || {
-            crate::error::generate_error(quote! {}, input.clone());
+            crate::error::generate_error(input.clone());
         });
     }
 }
@@ -63,7 +51,7 @@ fn test_contract_error_discriminant_must_be_integer_literal() {
             }
         };
         assert_panics_contains(case, "Error enum discriminant must be an integer literal", || {
-            crate::error::generate_error(quote! {}, input.clone());
+            crate::error::generate_error(input.clone());
         });
     }
 }
@@ -77,7 +65,7 @@ fn test_contract_error_discriminant_must_fit_u32() {
     };
 
     assert_panics_contains("u32::MAX + 1", "Error enum discriminant must be a valid u32 integer", || {
-        crate::error::generate_error(quote! {}, input);
+        crate::error::generate_error(input);
     });
 }
 
@@ -121,7 +109,7 @@ fn test_contract_error_discriminants_ordering_rejections_table_driven() {
             }
         };
         assert_panics_contains(case, "Error enum discriminant must be greater than the previous discriminant", || {
-            crate::error::generate_error(quote! {}, input.clone());
+            crate::error::generate_error(input.clone());
         });
     }
 }
@@ -135,7 +123,7 @@ fn test_contract_error_max_not_last_panics_overflow() {
         }
     };
     assert_panics_contains("max not last overflows", "attempt to add with overflow", || {
-        crate::error::generate_error(quote! {}, input);
+        crate::error::generate_error(input);
     });
 }
 
@@ -161,7 +149,7 @@ fn snapshot_generated_contract_error_code() {
         }
     };
 
-    let result = crate::error::generate_error(quote! {}, input);
+    let result = crate::error::generate_error(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/lz_contract.rs

@@ -0,0 +1,80 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
+
+// ============================================
+// Snapshot Tests: lz_contract Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_lz_contract_code() {
+    let input = quote! {
+        pub struct MyContract;
+    };
+
+    let default_result = crate::lz_contract::generate_lz_contract(TokenStream::new(), input.clone());
+    let default_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(default_result).expect("failed to parse generated code"));
+
+    let multisig_upgradeable_result = crate::lz_contract::generate_lz_contract(quote! { multisig, upgradeable }, input);
+    let multisig_upgradeable_formatted = prettyplease::unparse(
+        &syn::parse2::<syn::File>(multisig_upgradeable_result).expect("failed to parse generated code"),
+    );
+
+    let upgradeable_no_migration_result =
+        crate::lz_contract::generate_lz_contract(quote! { upgradeable(no_migration) }, quote! { pub struct MyContract; });
+    let upgradeable_no_migration_formatted = prettyplease::unparse(
+        &syn::parse2::<syn::File>(upgradeable_no_migration_result).expect("failed to parse generated code"),
+    );
+
+    let combined = format!(
+        "// === Default (ownable) ===\n\n{}\n\n// === MultiSig + Upgradeable ===\n\n{}\n\n// === Upgradeable (no_migration) ===\n\n{}",
+        default_formatted, multisig_upgradeable_formatted, upgradeable_no_migration_formatted
+    );
+
+    insta::assert_snapshot!(combined);
+}
+
+// ============================================
+// Error Cases: Invalid Config
+// ============================================
+
+#[test]
+fn test_lz_contract_invalid_config_table_driven() {
+    let input = quote! { pub struct MyContract; };
+
+    let cases: Vec<(&str, TokenStream, &str)> = vec![
+        (
+            "unknown option",
+            quote! { not_a_real_option },
+            "expected one of `upgradeable`, `multisig`",
+        ),
+        ("invalid attr syntax", quote! { 123 }, "failed to parse lz_contract config"),
+        ("upgradeable(bad_inner)", quote! { upgradeable(not_migration) }, "expected `no_migration`"),
+        (
+            "upgradeable(extra_tokens)",
+            quote! { upgradeable(no_migration, extra) },
+            "unexpected tokens in `upgradeable(...)`",
+        ),
+    ];
+
+    for (case, attr, expected_substring) in cases {
+        assert_panics_contains(case, expected_substring, || {
+            crate::lz_contract::generate_lz_contract(attr.clone(), input.clone());
+        });
+    }
+}
+
+// ============================================
+// Error Cases: Non-Struct Input
+// ============================================
+
+#[test]
+fn test_lz_contract_rejects_non_struct_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["struct"]) {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::lz_contract::generate_lz_contract(TokenStream::new(), input.clone());
+        });
+    }
+}

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

@@ -1,8 +1,10 @@
 mod auth;
 mod contract_ttl;
 mod error;
+mod lz_contract;
 mod storage;
 mod test_helpers;
 mod ttl_configurable;
+mod ttl_extendable;
 mod upgradeable;
 mod utils;

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

@@ -1,9 +1,11 @@
 ---
 source: contracts/common-macros/src/tests/auth.rs
-expression: formatted
+expression: combined
 ---
+// === Unit struct ===
+
 pub struct MyContract;
-use utils::{auth::Auth as _, multisig::Multisig as _};
+use utils::{auth::Auth as _, multisig::MultiSig as _};
 #[common_macros::contract_impl]
 impl utils::auth::Auth for MyContract {
     fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
@@ -11,4 +13,19 @@ impl utils::auth::Auth for MyContract {
     }
 }
 #[common_macros::contract_impl(contracttrait)]
-impl utils::multisig::Multisig for MyContract {}
+impl utils::multisig::MultiSig for MyContract {}
+
+
+// === Tuple struct ===
+
+#[derive(Copy, Clone)]
+pub struct MyContract(pub u32);
+use utils::{auth::Auth as _, multisig::MultiSig as _};
+#[common_macros::contract_impl]
+impl utils::auth::Auth for MyContract {
+    fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        env.current_contract_address()
+    }
+}
+#[common_macros::contract_impl(contracttrait)]
+impl utils::multisig::MultiSig for MyContract {}

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

@@ -1,7 +1,9 @@
 ---
 source: contracts/common-macros/src/tests/auth.rs
-expression: formatted
+expression: combined
 ---
+// === Unit struct ===
+
 pub struct MyContract;
 use utils::{
     auth::Auth as _, option_ext::OptionExt as _,
@@ -17,3 +19,28 @@ impl utils::auth::Auth for MyContract {
 }
 #[common_macros::contract_impl(contracttrait)]
 impl utils::ownable::Ownable for MyContract {}
+
+
+// === Generics + fields ===
+
+#[derive(Clone, Debug)]
+pub struct MyContract<T>
+where
+    T: Clone,
+{
+    pub value: T,
+}
+use utils::{
+    auth::Auth as _, option_ext::OptionExt as _,
+    ownable::{Ownable as _, OwnableInitializer as _},
+};
+impl utils::ownable::OwnableInitializer for MyContract {}
+#[common_macros::contract_impl]
+impl utils::auth::Auth for MyContract {
+    fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        <Self as utils::ownable::Ownable>::owner(env)
+            .unwrap_or_panic(env, utils::errors::OwnableError::OwnerNotSet)
+    }
+}
+#[common_macros::contract_impl(contracttrait)]
+impl utils::ownable::Ownable for MyContract {}

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

@@ -1,43 +1,26 @@
 ---
 source: contracts/common-macros/src/tests/contract_ttl.rs
-assertion_line: 109
 expression: combined
 ---
 // === Inherent Impl (no attr) ===
 
 #[soroban_sdk::contractimpl]
 impl MyContract {
+    const A_CONST: u32 = 1;
+    type Alias = u32;
     /// 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_configurable::TtlConfigStorage::instance(
-            &env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(&env);
         value * 2
     }
     /// 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_configurable::TtlConfigStorage::instance(
-            &env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(&env);
         42
     }
     /// Public method with Env not as first parameter - should have TTL extension
     pub fn env_second(value: u32, env: &Env) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(env);
         value * 2
     }
     /// Public method without Env - should NOT have TTL extension
@@ -66,13 +49,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_configurable::TtlConfigStorage::instance(
-            &env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(&env);
         value * 2
     }
     /// Trait method without Env - should NOT have TTL extension
@@ -82,13 +59,7 @@ impl SomeTrait for MyContract {
     /// Trait method with macro attribute - should have TTL extension
     #[common_macros::only_auth]
     fn trait_method_with_only_auth_attribute(env: Env, value: u32) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            &env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(&env);
         value * 5
     }
 }
@@ -100,13 +71,7 @@ impl SomeTrait for MyContract {
 impl AnotherTrait for MyContract {
     /// Trait method with contracttrait attr - should have TTL extension
     fn contracttrait_method(env: &Env, value: u32) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(env);
         value * 3
     }
 }

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

@@ -1,43 +1,26 @@
 ---
 source: contracts/common-macros/src/tests/contract_ttl.rs
-assertion_line: 75
 expression: combined
 ---
 // === Trait (no attr) ===
 
 #[soroban_sdk::contracttrait]
 pub trait MyTrait: Sized {
+    const A_CONST: u32;
+    type Alias;
     /// Default method with Env - should have TTL extension
     fn default_with_env(env: Env, value: u32) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            &env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(&env);
         value * 2
     }
     /// Default method with qualified Env path - should have TTL extension
     fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            &env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(&env);
         42
     }
     /// Default method with Env not as first parameter - should have TTL extension
     fn env_second(value: u32, env: &Env) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(env);
         value * 2
     }
     /// Default method without Env - should NOT have TTL extension
@@ -57,13 +40,7 @@ pub trait MyTrait: Sized {
 pub trait AnotherTrait {
     /// Default method with Env - should have TTL extension
     fn method_with_env(env: &Env, value: u32) -> u32 {
-        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
-            env,
-        ) {
-            env.storage()
-                .instance()
-                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
-        }
+        utils::ttl_configurable::extend_instance_ttl(env);
         value * 3
     }
 }

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

@@ -0,0 +1,31 @@
+---
+source: contracts/common-macros/src/tests/lz_contract.rs
+expression: combined
+---
+// === Default (ownable) ===
+
+#[soroban_sdk::contract]
+#[common_macros::ttl_configurable]
+#[common_macros::ttl_extendable]
+#[common_macros::ownable]
+pub struct MyContract;
+
+
+// === MultiSig + Upgradeable ===
+
+#[soroban_sdk::contract]
+#[common_macros::ttl_configurable]
+#[common_macros::ttl_extendable]
+#[common_macros::multisig]
+#[common_macros::upgradeable]
+pub struct MyContract;
+
+
+// === Upgradeable (no_migration) ===
+
+#[soroban_sdk::contract]
+#[common_macros::ttl_configurable]
+#[common_macros::ttl_extendable]
+#[common_macros::ownable]
+#[common_macros::upgradeable(no_migration)]
+pub struct MyContract;

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

@@ -0,0 +1,8 @@
+---
+source: contracts/common-macros/src/tests/ttl_extendable.rs
+expression: formatted
+---
+pub struct MyContract;
+use utils::ttl_extendable::TtlExtendable as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl utils::ttl_extendable::TtlExtendable for MyContract {}

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

@@ -0,0 +1,87 @@
+//! Unit tests for the `extract_fields` function.
+
+use crate::storage::test::extract_fields_for_test;
+use crate::tests::test_helpers::assert_panics_contains;
+use quote::{quote, ToTokens};
+
+use super::test_setup::parse_variant;
+
+#[test]
+fn test_unit_variant_returns_empty() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            UnitVariant,
+        }
+    });
+
+    let fields = extract_fields_for_test(&variant);
+    assert!(fields.is_empty(), "unit variant should have no fields");
+}
+
+#[test]
+fn test_named_variant_single_field() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { key: Address },
+        }
+    });
+
+    let fields = extract_fields_for_test(&variant);
+    assert_eq!(fields.len(), 1, "should have exactly one field");
+    assert_eq!(fields[0].0.to_string(), "key");
+    assert_eq!(fields[0].1.to_token_stream().to_string(), "Address");
+}
+
+#[test]
+fn test_named_variant_multiple_fields() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { first: u32, second: String, third: Address },
+        }
+    });
+
+    let fields = extract_fields_for_test(&variant);
+    assert_eq!(fields.len(), 3, "should have exactly three fields");
+    assert_eq!(fields[0].0.to_string(), "first");
+    assert_eq!(fields[1].0.to_string(), "second");
+    assert_eq!(fields[2].0.to_string(), "third");
+
+    assert_eq!(fields[0].1.to_token_stream().to_string(), "u32");
+    assert_eq!(fields[1].1.to_token_stream().to_string(), "String");
+    assert_eq!(fields[2].1.to_token_stream().to_string(), "Address");
+}
+
+#[test]
+fn test_tuple_variant_panics() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            TupleVariant(u32, String),
+        }
+    });
+
+    assert_panics_contains("tuple variant", "only unit variants or named fields are supported", || {
+        extract_fields_for_test(&variant);
+    });
+}
+
+#[test]
+fn test_preserves_field_order() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            OrderedVariant { alpha: u32, beta: String, gamma: Address, delta: bool },
+        }
+    });
+
+    let fields = extract_fields_for_test(&variant);
+    let names: Vec<_> = fields.iter().map(|(name, _)| name.to_string()).collect();
+    assert_eq!(names, vec!["alpha", "beta", "gamma", "delta"]);
+
+    assert_eq!(fields[0].1.to_token_stream().to_string(), "u32");
+    assert_eq!(fields[1].1.to_token_stream().to_string(), "String");
+    assert_eq!(fields[2].1.to_token_stream().to_string(), "Address");
+    assert_eq!(fields[3].1.to_token_stream().to_string(), "bool");
+}