@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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

@@ -0,0 +1,83 @@
+//! LzContract wrapper macro for Stellar smart contracts.
+//!
+//! This module provides the `#[lz_contract]` macro which combines commonly used
+//! LayerZero contract attributes into a single macro invocation.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    Error, Ident, ItemStruct, Token,
+};
+
+/// Configuration options for the `#[lz_contract]` macro.
+#[derive(Debug, Default)]
+pub struct LzContractConfig {
+    /// If true, adds `#[upgradeable]` for contract upgrade support.
+    pub upgradeable: bool,
+    /// If true, uses `#[multisig]` instead of `#[ownable]` for auth.
+    pub multisig: bool,
+}
+
+impl Parse for LzContractConfig {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if input.is_empty() {
+            return Ok(Self::default());
+        }
+
+        let idents = Punctuated::<Ident, Token![,]>::parse_terminated(input)?;
+        let mut config = Self::default();
+
+        for ident in idents {
+            match ident.to_string().as_str() {
+                "upgradeable" => config.upgradeable = true,
+                "multisig" => config.multisig = true,
+                _ => {
+                    return Err(Error::new(ident.span(), "expected one of `upgradeable`, `multisig`"));
+                }
+            }
+        }
+
+        Ok(config)
+    }
+}
+
+/// Generates a complete LayerZero contract with common macro attributes.
+///
+/// # Default (no options)
+/// Generates:
+/// - `#[soroban_sdk::contract]` - Soroban contract
+/// - `#[common_macros::ttl_configurable]` - TTL configuration with auth
+/// - `#[common_macros::ttl_extendable]` - Manual TTL extension
+/// - `#[common_macros::ownable]` - Single-owner access control
+///
+/// # Options
+/// - `upgradeable` - Adds `#[common_macros::upgradeable]` for contract upgrade support
+/// - `multisig` - Uses `#[common_macros::multisig]` instead of `#[common_macros::ownable]`
+pub fn generate_lz_contract(attr: TokenStream, input: TokenStream) -> TokenStream {
+    let config: LzContractConfig =
+        syn::parse2(attr).unwrap_or_else(|e| panic!("failed to parse lz_contract config: {}", e));
+    let item: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
+
+    let auth = if config.multisig {
+        quote! { #[common_macros::multisig] }
+    } else {
+        quote! { #[common_macros::ownable] }
+    };
+
+    let upgrade = if config.upgradeable {
+        quote! { #[common_macros::upgradeable] }
+    } else {
+        quote! {}
+    };
+
+    quote! {
+        #[soroban_sdk::contract]
+        #[common_macros::ttl_configurable]
+        #[common_macros::ttl_extendable]
+        #auth
+        #upgrade
+        #item
+    }
+}

package/contracts/common-macros/src/tests/{ownable.rs → auth.rs}

@@ -2,6 +2,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 
 use crate::tests::test_helpers::{assert_panics_contains, non_struct_item_inputs};
+
 // ============================================
 // Snapshot Test: Ownable Code Generation
 // ============================================
@@ -11,21 +12,40 @@ fn snapshot_generated_ownable_code() {
     let input = quote! {
         pub struct MyContract;
     };
-    let result = crate::ownable::generate_ownable_impl(input);
+    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);
+}
+
+// ============================================
+// Snapshot Test: Multisig Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_multisig_code() {
+    let input = quote! {
+        pub struct MyContract;
+    };
+    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);
 }
 
+// ============================================
+// Snapshot Test: Only Auth Macro
+// ============================================
+
 #[test]
-fn snapshot_only_owner_preserves_function_signature() {
+fn snapshot_only_auth_preserves_function_signature() {
     // 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_borrowed = crate::ownable::prepend_only_owner_check(input_borrowed);
+    let result_borrowed = crate::auth::prepend_only_auth_check(input_borrowed);
     let formatted_borrowed =
         prettyplease::unparse(&syn::parse2::<syn::File>(result_borrowed).expect("failed to parse generated code"));
 
@@ -35,7 +55,7 @@ fn snapshot_only_owner_preserves_function_signature() {
             Ok(value.clone())
         }
     };
-    let result_owned = crate::ownable::prepend_only_owner_check(input_owned);
+    let result_owned = crate::auth::prepend_only_auth_check(input_owned);
     let formatted_owned =
         prettyplease::unparse(&syn::parse2::<syn::File>(result_owned).expect("failed to parse generated code"));
 
@@ -49,30 +69,30 @@ fn snapshot_only_owner_preserves_function_signature() {
 }
 
 // ============================================
-// prepend_only_owner_check Tests
+// prepend_only_auth_check Tests
 // ============================================
 
-/// Helper function to verify that the owner check is correctly inserted at the beginning of a function.
-fn assert_owner_check_inserted(input: TokenStream, expected_env_ref: &str, test_name: &str) {
-    let result_tokens = crate::ownable::prepend_only_owner_check(input);
+/// Helper function to verify that the auth check is correctly inserted at the beginning of a function.
+fn assert_auth_check_inserted(input: TokenStream, expected_env_ref: &str, test_name: &str) {
+    let result_tokens = crate::auth::prepend_only_auth_check(input);
     let output_fn: syn::ItemFn =
         syn::parse2(result_tokens).unwrap_or_else(|e| panic!("{}: failed to parse output function: {}", test_name, e));
 
     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 = format!("utils::ownable::require_owner_auth::<Self>({});", expected_env_ref);
+    let expected_stmt = format!("utils::auth::require_auth::<Self>({});", expected_env_ref);
     let actual_stmt = quote::quote!(#first_stmt).to_string().replace(" ", "");
 
     assert_eq!(
         actual_stmt, expected_stmt,
-        "{}: expected owner check statement '{}', but got '{}'",
+        "{}: expected auth check statement '{}', but got '{}'",
         test_name, expected_stmt, actual_stmt
     );
 }
 
 #[test]
-fn test_only_owner_inserts_correct_code_at_the_beginning() {
+fn test_only_auth_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![
@@ -88,12 +108,12 @@ fn test_only_owner_inserts_correct_code_at_the_beginning() {
     ];
 
     for (description, input, expected_env_ref) in test_cases {
-        assert_owner_check_inserted(input, expected_env_ref, description);
+        assert_auth_check_inserted(input, expected_env_ref, description);
     }
 }
 
 #[test]
-fn test_only_owner_requires_env_param() {
+fn test_only_auth_requires_env_param() {
     // ============================================
     // Error Cases: Missing/Invalid Env Argument Patterns
     // ============================================
@@ -109,7 +129,7 @@ fn test_only_owner_requires_env_param() {
 
     for (case, input) in cases {
         assert_panics_contains(case, "function must have an Env argument", || {
-            crate::ownable::prepend_only_owner_check(input.clone());
+            crate::auth::prepend_only_auth_check(input.clone());
         });
     }
 }
@@ -122,7 +142,20 @@ fn test_only_owner_requires_env_param() {
 fn test_ownable_rejects_non_struct_inputs() {
     for (case, input) in non_struct_item_inputs() {
         assert_panics_contains(case, "failed to parse struct", || {
-            crate::ownable::generate_ownable_impl(input.clone());
+            crate::auth::generate_ownable_impl(input.clone());
+        });
+    }
+}
+
+// ============================================
+// Error Cases: multisig macro non-struct input
+// ============================================
+
+#[test]
+fn test_multisig_rejects_non_struct_inputs() {
+    for (case, input) in non_struct_item_inputs() {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::auth::generate_multisig_impl(input.clone());
         });
     }
 }