@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

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

@@ -22,35 +22,23 @@ use syn::{parse_quote, ItemFn, ItemStruct};
 pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
     let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
     let name = &item_struct.ident;
-    let impl_mod = utils::impl_mod_ident(name, "ownable");
 
     quote! {
         #item_struct
 
-        use utils::{auth::Auth as _, ownable::{Ownable as _, OwnableInitializer as _}};
-
-        #[doc(hidden)]
-        mod #impl_mod {
-            use super::*;
-            use utils::{
-                auth::Auth,
-                errors::OwnableError,
-                option_ext::OptionExt as _,
-                ownable::{Ownable, OwnableInitializer},
-            };
-
-            impl OwnableInitializer for #name {}
-
-            #[common_macros::contract_impl]
-            impl Auth for #name {
-                fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
-                    <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
-                }
-            }
+        use utils::{auth::Auth as _, option_ext::OptionExt as _, ownable::{Ownable as _, OwnableInitializer as _}};
+
+        impl utils::ownable::OwnableInitializer for #name {}
 
-            #[common_macros::contract_impl(contracttrait)]
-            impl Ownable for #name {}
+        #[common_macros::contract_impl]
+        impl utils::auth::Auth for #name {
+            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 #name {}
     }
 }
 
@@ -66,28 +54,21 @@ pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
 pub fn generate_multisig_impl(input: TokenStream) -> TokenStream {
     let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
     let name = &item_struct.ident;
-    let impl_mod = utils::impl_mod_ident(name, "multisig");
 
     quote! {
         #item_struct
 
         use utils::{auth::Auth as _, multisig::Multisig as _};
 
-        #[doc(hidden)]
-        mod #impl_mod {
-            use super::*;
-            use utils::{auth::Auth, multisig::Multisig};
-
-            #[common_macros::contract_impl]
-            impl Auth for #name {
-                fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
-                    env.current_contract_address()
-                }
+        #[common_macros::contract_impl]
+        impl utils::auth::Auth for #name {
+            fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+                env.current_contract_address()
             }
-
-            #[common_macros::contract_impl(contracttrait)]
-            impl Multisig for #name {}
         }
+
+        #[common_macros::contract_impl(contracttrait)]
+        impl utils::multisig::Multisig for #name {}
     }
 }
 

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

@@ -4,6 +4,9 @@ use quote::quote;
 use syn::{ImplItem, ItemImpl, ItemTrait, TraitItem, Visibility};
 
 /// Generates a `#[soroban_sdk::contractimpl]` with automatic instance TTL extension.
+///
+/// - For `__constructor` methods: injects `ttl_configurable::init_default_ttl_configs(env)`
+/// - For other methods: injects TTL extension logic to extend instance TTL if configured
 pub fn contractimpl_with_ttl(attr: TokenStream, input: TokenStream) -> TokenStream {
     let mut impl_block: ItemImpl = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse impl block: {}", e));
 
@@ -17,16 +20,16 @@ pub fn contractimpl_with_ttl(attr: TokenStream, input: TokenStream) -> TokenStre
             continue;
         }
 
-        // Skip the constructor as TTL config is typically not set during initialization
-        if method.sig.ident == "__constructor" {
-            continue;
-        }
-
         // Skip methods without Env parameter
         let Some(env_param) = utils::find_env_param(&method.sig.inputs) else { continue };
 
-        // Inject TTL extension at the start of the method body
-        method.block.stmts.insert(0, extend_instance_ttl_stmt(&env_param));
+        if method.sig.ident == "__constructor" {
+            // Inject default TTL config initialization in constructor
+            method.block.stmts.insert(0, init_default_ttl_configs_stmt(&env_param));
+        } else {
+            // Inject TTL extension at the start of other methods
+            method.block.stmts.insert(0, extend_instance_ttl_stmt(&env_param));
+        }
     }
 
     let contract_attr = if attr.is_empty() {
@@ -72,6 +75,14 @@ pub fn contracttrait_with_ttl(attr: TokenStream, input: TokenStream) -> TokenStr
     }
 }
 
+/// Generates a statement that initializes default TTL configs in the constructor.
+fn init_default_ttl_configs_stmt(env_param: &utils::EnvParam<'_>) -> syn::Stmt {
+    let env_ref = env_param.as_ref_tokens();
+    syn::parse_quote! {
+        utils::ttl_configurable::init_default_ttl_configs(#env_ref);
+    }
+}
+
 /// Generates a statement that extends instance TTL if configured.
 fn extend_instance_ttl_stmt(env_param: &utils::EnvParam<'_>) -> syn::Stmt {
     let env_ref = env_param.as_ref_tokens();

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

@@ -386,36 +386,48 @@ pub fn contract_trait(attr: TokenStream, item: TokenStream) -> TokenStream {
 // Upgradeable Macro
 // ============================================================================
 
-/// Generates upgradeable implementation with auth-based access control.
+/// Generates upgradeable implementation using the `Upgradeable` trait's default methods.
 ///
-/// Implements the `Upgradeable` trait for contract upgrade and migration functionality.
+/// This macro implements `Upgradeable` using the trait's default methods (which include auth).
 ///
 /// # Requirements
 /// - The contract must implement the `Auth` trait (via `#[ownable]` or `Multisig`)
-/// - The contract must implement `UpgradeableInternal` trait with migration logic
+/// - By default, requires manual `UpgradeableInternal` implementation
+/// - With `no_migration` flag, auto-generates a no-op `UpgradeableInternal` impl
+///
+/// # Options
+/// - `#[upgradeable]` - Requires manual `UpgradeableInternal` implementation (safety by default)
+/// - `#[upgradeable(no_migration)]` - Auto-generates no-op `UpgradeableInternal` (for initial deployment)
 ///
 /// # Example
 /// ```ignore
-/// #[ownable]  // or implement Multisig for self-owning contracts
+/// // Requires manual UpgradeableInternal implementation (default)
+/// #[ownable]
 /// #[upgradeable]
 /// pub struct MyContract;
 ///
 /// impl utils::upgradeable::UpgradeableInternal for MyContract {
-///     type MigrationData = ();
+///     type MigrationData = MyMigrationParams;
 ///
-///     fn _migrate(env: &Env, migration_data: &Self::MigrationData) {
-///         // Migration logic here
+///     fn __migrate(env: &Env, migration_data: &Self::MigrationData) {
+///         // Custom migration logic here
 ///     }
 /// }
+///
+/// // Auto-generates no-op UpgradeableInternal (for initial deployment)
+/// #[ownable]
+/// #[upgradeable(no_migration)]
+/// pub struct MyContract;
+/// // No UpgradeableInternal impl needed!
 /// ```
 ///
 /// Generated code includes:
 /// - `upgrade(env, new_wasm_hash)` - Upgrades the contract WASM (auth required)
-/// - `migrate(env, migration_data)` - Runs migration after upgrade (auth required)
+/// - `migrate(env, migration_data)` - Runs migration after upgrade (auth required, XDR-decodes `Bytes` to `MigrationData`)
 /// - `contractmeta!` with `binver` set to the Cargo package version (if not 0.0.0)
 #[proc_macro_attribute]
-pub fn upgradeable(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    upgradeable::generate_upgradeable_impl(item.into()).into()
+pub fn upgradeable(attr: TokenStream, item: TokenStream) -> TokenStream {
+    upgradeable::generate_upgradeable_impl(attr.into(), item.into()).into()
 }
 
 // ============================================================================
@@ -435,7 +447,8 @@ pub fn upgradeable(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// - `#[ownable]` - Single-owner access control
 ///
 /// # Options
-/// - `upgradeable` - Adds `#[upgradeable]` for contract upgrade support
+/// - `upgradeable` - Adds `#[upgradeable]`, requires manual `UpgradeableInternal` impl
+/// - `upgradeable(no_migration)` - Adds `#[upgradeable(no_migration)]`, auto-generates no-op impl
 /// - `multisig` - Uses `#[multisig]` instead of `#[ownable]`
 ///
 /// # Examples
@@ -444,12 +457,16 @@ pub fn upgradeable(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// #[lz_contract]
 /// pub struct EndpointV2;
 ///
-/// // Contract with upgrade support
+/// // Contract with upgrade support (requires manual UpgradeableInternal)
 /// #[lz_contract(upgradeable)]
 /// pub struct DVNFeeLib;
 ///
-/// // Contract with multisig auth and upgrade support
-/// #[lz_contract(multisig, upgradeable)]
+/// // Contract with upgrade support and no migration (auto no-op impl)
+/// #[lz_contract(upgradeable(no_migration))]
+/// pub struct DVNFeeLib;
+///
+/// // Contract with multisig auth and upgrade support (no migration)
+/// #[lz_contract(multisig, upgradeable(no_migration))]
 /// pub struct DVN;
 /// ```
 #[proc_macro_attribute]

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

@@ -6,8 +6,8 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{
+    parenthesized,
     parse::{Parse, ParseStream},
-    punctuated::Punctuated,
     Error, Ident, ItemStruct, Token,
 };
 
@@ -16,6 +16,9 @@ use syn::{
 pub struct LzContractConfig {
     /// If true, adds `#[upgradeable]` for contract upgrade support.
     pub upgradeable: bool,
+    /// If true, generates a default no-op `UpgradeableInternal` implementation.
+    /// Only valid when `upgradeable` is also true.
+    pub no_migration: bool,
     /// If true, uses `#[multisig]` instead of `#[ownable]` for auth.
     pub multisig: bool,
 }
@@ -26,17 +29,40 @@ impl Parse for LzContractConfig {
             return Ok(Self::default());
         }
 
-        let idents = Punctuated::<Ident, Token![,]>::parse_terminated(input)?;
         let mut config = Self::default();
 
-        for ident in idents {
+        // Parse comma-separated items, handling nested parentheses for upgradeable(no_migration)
+        while !input.is_empty() {
+            let ident: Ident = input.parse()?;
+
             match ident.to_string().as_str() {
-                "upgradeable" => config.upgradeable = true,
+                "upgradeable" => {
+                    config.upgradeable = true;
+                    // Check for optional (no_migration) suffix
+                    if input.peek(syn::token::Paren) {
+                        let content;
+                        parenthesized!(content in input);
+                        let inner_ident: Ident = content.parse()?;
+                        if inner_ident == "no_migration" {
+                            config.no_migration = true;
+                        } else {
+                            return Err(Error::new(inner_ident.span(), "expected `no_migration`"));
+                        }
+                        if !content.is_empty() {
+                            return Err(Error::new(content.span(), "unexpected tokens in `upgradeable(...)`"));
+                        }
+                    }
+                }
                 "multisig" => config.multisig = true,
                 _ => {
                     return Err(Error::new(ident.span(), "expected one of `upgradeable`, `multisig`"));
                 }
             }
+
+            // Consume optional trailing comma
+            if input.peek(Token![,]) {
+                let _: Token![,] = input.parse()?;
+            }
         }
 
         Ok(config)
@@ -53,8 +79,9 @@ impl Parse for LzContractConfig {
 /// - `#[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]`
+/// - `upgradeable` - Adds `#[upgradeable]`, requires manual `UpgradeableInternal` impl
+/// - `upgradeable(no_migration)` - Adds `#[upgradeable(no_migration)]`, auto-generates no-op impl
+/// - `multisig` - Uses `#[multisig]` instead of `#[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));
@@ -67,7 +94,11 @@ pub fn generate_lz_contract(attr: TokenStream, input: TokenStream) -> TokenStrea
     };
 
     let upgrade = if config.upgradeable {
-        quote! { #[common_macros::upgradeable] }
+        if config.no_migration {
+            quote! { #[common_macros::upgradeable(no_migration)] }
+        } else {
+            quote! { #[common_macros::upgradeable] }
+        }
     } else {
         quote! {}
     };