@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.22

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

@@ -77,9 +77,9 @@ 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_ident = env_param.ident;
+    let env_ref = env_param.as_ref_tokens();
     syn::parse_quote! {
-        utils::ttl_configurable::init_default_ttl_configs(#env_ident);
+        utils::ttl_configurable::init_default_ttl_configs(#env_ref);
     }
 }
 

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

@@ -392,21 +392,33 @@ pub fn contract_trait(attr: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// # 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
+///         // 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:
@@ -414,8 +426,8 @@ pub fn contract_trait(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// - `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! {}
     };