@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

package/Cargo.lock

@@ -609,7 +609,6 @@ dependencies = [
 name = "dvn-fee-lib"
 version = "0.0.1"
 dependencies = [
- "cfg-if",
  "common-macros",
  "message-lib-common",
  "soroban-sdk",
@@ -750,7 +749,6 @@ dependencies = [
 name = "executor-helper"
 version = "0.0.1"
 dependencies = [
- "cfg-if",
  "common-macros",
  "endpoint-v2",
  "executor",
@@ -1038,6 +1036,19 @@ dependencies = [
  "cpufeatures",
 ]
 
+[[package]]
+name = "layerzero-views"
+version = "0.0.1"
+dependencies = [
+ "cfg-if",
+ "common-macros",
+ "endpoint-v2",
+ "message-lib-common",
+ "soroban-sdk",
+ "uln302",
+ "utils",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.177"
@@ -1056,6 +1067,19 @@ version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
+[[package]]
+name = "macro-integration-tests"
+version = "0.0.1"
+dependencies = [
+ "common-macros",
+ "endpoint-v2",
+ "oapp",
+ "oapp-macros",
+ "soroban-sdk",
+ "trybuild",
+ "utils",
+]
+
 [[package]]
 name = "macro-string"
 version = "0.1.4"
@@ -1182,9 +1206,11 @@ version = "0.0.1"
 dependencies = [
  "common-macros",
  "endpoint-v2",
+ "message-lib-common",
  "oapp",
  "oapp-macros",
  "oft",
+ "simple-message-lib",
  "soroban-sdk",
  "utils",
 ]
@@ -1259,7 +1285,6 @@ name = "price-feed"
 version = "0.0.1"
 dependencies = [
  "common-macros",
- "endpoint-v2",
  "soroban-sdk",
  "utils",
  "worker",
@@ -1471,6 +1496,15 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "serde_with"
 version = "3.15.1"
@@ -1910,6 +1944,21 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "target-triple"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b"
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -1961,6 +2010,45 @@ dependencies = [
  "time-core",
 ]
 
+[[package]]
+name = "toml"
+version = "0.9.10+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0825052159284a1a8b4d6c0c86cbc801f2da5afd2b225fa548c72f2e74002f48"
+dependencies = [
+ "indexmap 2.12.0",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+
 [[package]]
 name = "treasury"
 version = "0.0.1"
@@ -1974,6 +2062,21 @@ dependencies = [
  "utils",
 ]
 
+[[package]]
+name = "trybuild"
+version = "1.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335"
+dependencies = [
+ "glob",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "target-triple",
+ "termcolor",
+ "toml",
+]
+
 [[package]]
 name = "ts-bindings-gen"
 version = "0.0.1"
@@ -2006,6 +2109,15 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
+[[package]]
+name = "upgrader"
+version = "0.0.1"
+dependencies = [
+ "common-macros",
+ "soroban-sdk",
+ "utils",
+]
+
 [[package]]
 name = "utils"
 version = "0.0.1"
@@ -2136,6 +2248,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
@@ -2274,6 +2395,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "winnow"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+
 [[package]]
 name = "worker"
 version = "0.0.1"

package/Cargo.toml

@@ -20,8 +20,9 @@ hex-literal = "1.0.0"
 endpoint-v2 = { path = "contracts/endpoint-v2", default-features = false }
 utils = { path = "contracts/utils" }
 common-macros = { path = "contracts/common-macros" }
-oapp-macros = { path = "contracts/oapp-macros" }
+oapp-macros = { path = "contracts/oapps/oapp-macros" }
 message-lib-common = { path = "contracts/message-libs/message-lib-common" }
+uln302 = { path = "contracts/message-libs/uln-302", default-features = false }
 oapp = { path = "contracts/oapps/oapp" }
 simple-message-lib = { path = "contracts/message-libs/simple-message-lib" }
 treasury = { path = "contracts/message-libs/treasury" }

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

@@ -17,6 +17,11 @@ pub fn contract_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
             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 };
 
@@ -26,7 +31,7 @@ pub fn contract_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
 
         // Use fully qualified syntax to call ttl_configs from TtlConfigurable trait
         let extend_ttl_stmt = parse_quote! {
-            if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(#env_ref) {
+            if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(#env_ref) {
                 #env_ident.storage().instance().extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
             }
         };

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

@@ -13,6 +13,8 @@
 //! - [`only_owner`] - Owner-only access control attribute macro
 //! - [`ttl_configurable`] - TTL configuration with freeze support
 //! - [`contract_impl`] - Contract impl with automatic instance TTL extension
+//! - [`upgradeable`] - Upgradeable trait implementation macro
+//!
 //!
 use proc_macro::TokenStream;
 
@@ -21,6 +23,7 @@ mod error;
 mod ownable;
 mod storage;
 mod ttl_configurable;
+mod upgradeable;
 mod utils;
 
 #[cfg(test)]
@@ -185,14 +188,17 @@ pub fn only_owner(_attr: TokenStream, item: TokenStream) -> TokenStream {
 // TTL Configuration Macro
 // ============================================================================
 
-/// Generates TtlConfigurable trait implementation with ownable support.
+/// Generates TtlConfigurable trait implementation.
+///
+/// This macro implements the `TtlConfigurable` trait for a contract struct,
+/// providing TTL configuration management with owner-only access control.
 ///
-/// This macro automatically applies `#[ownable]` for owner management.:
-/// - `#[ownable]` - Applies the ownable macro for owner management
-/// - TtlConfigurable trait implementation - TTL configuration with freeze support
+/// # Requirements
+/// The contract must implement the `Ownable` trait (typically via `#[ownable]`).
 ///
 /// # Example
 /// ```ignore
+/// #[ownable]
 /// #[ttl_configurable]
 /// pub struct MyContract;
 ///
@@ -205,13 +211,10 @@ pub fn only_owner(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 ///
 /// Generated code includes:
-/// - `#[ownable]` attribute on the struct (provides owner management)
 /// - `set_ttl_configs(env, instance, persistent)` - Set TTL configs (owner only)
 /// - `ttl_configs(env)` - Get current TTL configs (instance, persistent)
 /// - `freeze_ttl_configs(env)` - Permanently freeze TTL configs (owner only)
 /// - `is_ttl_configs_frozen(env)` - Check if TTL configs are frozen
-///
-/// See [`ownable`] for the owner management methods also generated.
 #[proc_macro_attribute]
 pub fn ttl_configurable(_attr: TokenStream, item: TokenStream) -> TokenStream {
     ttl_configurable::generate_ttl_configurable_impl(item.into()).into()
@@ -255,7 +258,7 @@ pub fn ttl_configurable(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// #[soroban_sdk::contractimpl]
 /// impl MyContract {
 ///     pub fn my_method(env: &Env) {
-///         if let Some(ttl) = <Self as ::utils::ttl::TtlConfigurable>::ttl_config(env).0 {
+///         if let Some(ttl) = <Self as ::utils::ttl_configurable::TtlConfigurable>::ttl_config(env).0 {
 ///             env.storage().instance().extend_ttl(ttl.threshold, ttl.extend_to);
 ///         }
 ///         // ... your code
@@ -266,3 +269,39 @@ pub fn ttl_configurable(_attr: TokenStream, item: TokenStream) -> TokenStream {
 pub fn contract_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
     contract_impl::contract_impl(attr.into(), item.into()).into()
 }
+
+// ============================================================================
+// Upgradeable Macro
+// ============================================================================
+
+/// Generates upgradeable implementation with owner-based access control.
+///
+/// Implements the `Upgradeable` trait for contract upgrade and migration functionality.
+///
+/// # Requirements
+/// - The contract must have `#[ownable]` applied for owner management
+/// - The contract must implement `UpgradeableInternal` trait with migration logic
+///
+/// # Example
+/// ```ignore
+/// #[ownable]
+/// #[upgradeable]
+/// pub struct MyContract;
+///
+/// impl utils::upgradeable::UpgradeableInternal for MyContract {
+///     type MigrationData = ();
+///
+///     fn _migrate(env: &Env, migration_data: &Self::MigrationData) {
+///         // Migration logic here
+///     }
+/// }
+/// ```
+///
+/// Generated code includes:
+/// - `upgrade(env, new_wasm_hash)` - Upgrades the contract WASM (owner only)
+/// - `migrate(env, migration_data)` - Runs migration after upgrade (owner only)
+/// - `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()
+}

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

@@ -9,33 +9,15 @@ pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
     let name = &item_struct.ident;
 
     let ownable_impl = quote! {
-        use utils::ownable::Ownable as _;
         use utils::ownable::OwnableInitializer as _;
+        use utils::ownable::Ownable;
 
-        /// Implement the OwnableInitializer trait for the contract.
-        impl utils::ownable::OwnableInitializer for #name {
-            fn init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
-                <utils::ownable::DefaultOwnable as utils::ownable::OwnableInitializer>::init_owner(env, owner)
-            }
-        }
-
-        /// Implement the Ownable trait for the contract.
-        #[common_macros::contract_impl]
-        impl utils::ownable::Ownable for #name {
-            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)
-            }
-        }
+        // Import OwnableInitializer at module level so user code can call Self::init_owner()
+        impl utils::ownable::OwnableInitializer for #name {}
+
+        /// Implement the Ownable trait for the contract with default implementations.
+        #[common_macros::contract_impl(contracttrait)]
+        impl Ownable for #name {}
     };
 
     quote! {

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

@@ -306,7 +306,7 @@ fn gen_ttl_extension(storage_type: &StorageType, use_stored_config: bool) -> Tok
     if use_stored_config {
         let method = format_ident!("{}", storage_type.accessor_name());
         quote! {
-            if let Some(utils::ttl::TtlConfig { threshold, extend_to }) = utils::ttl::TtlConfigStorage::#method(env) {
+            if let Some(utils::ttl_configurable::TtlConfig { threshold, extend_to }) = utils::ttl_configurable::TtlConfigStorage::#method(env) {
                 #extend_call
             }
         }

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

@@ -48,6 +48,11 @@ fn snapshot_generated_contract_impl_code() {
             pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
                 value * 7
             }
+
+            /// Constructor method - should NOT have TTL extension
+            pub fn __constructor(env: &Env, value: u32) {
+                let _ = value * 2;
+            }
         }
     };
 

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

@@ -4,4 +4,5 @@ mod ownable;
 mod storage;
 mod test_helpers;
 mod ttl_configurable;
+mod upgradeable;
 mod utils;

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: 104
+assertion_line: 109
 expression: combined
 ---
 // === Inherent Impl (no attr) ===
@@ -9,7 +9,9 @@ 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_configurable::TtlConfigStorage::instance(
+            &env,
+        ) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -18,7 +20,9 @@ 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_configurable::TtlConfigStorage::instance(
+            &env,
+        ) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -27,7 +31,9 @@ impl MyContract {
     }
     /// 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::TtlConfigStorage::instance(env) {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            env,
+        ) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -46,6 +52,10 @@ impl MyContract {
     pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
         value * 7
     }
+    /// Constructor method - should NOT have TTL extension
+    pub fn __constructor(env: &Env, value: u32) {
+        let _ = value * 2;
+    }
 }
 
 
@@ -55,7 +65,9 @@ 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_configurable::TtlConfigStorage::instance(
+            &env,
+        ) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -69,7 +81,9 @@ impl SomeTrait for MyContract {
     /// 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) {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            &env,
+        ) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
@@ -85,7 +99,9 @@ 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::TtlConfigStorage::instance(env) {
+        if let Some(instance_ttl) = utils::ttl_configurable::TtlConfigStorage::instance(
+            env,
+        ) {
             env.storage()
                 .instance()
                 .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);

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

@@ -4,29 +4,9 @@ assertion_line: 17
 expression: formatted
 ---
 pub struct MyContract;
-use utils::ownable::Ownable as _;
 use utils::ownable::OwnableInitializer as _;
-/// Implement the OwnableInitializer trait for the contract.
-impl utils::ownable::OwnableInitializer for MyContract {
-    fn init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
-        <utils::ownable::DefaultOwnable as utils::ownable::OwnableInitializer>::init_owner(
-            env,
-            owner,
-        )
-    }
-}
-/// Implement the Ownable trait for the contract.
-#[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)
-    }
-}
+use utils::ownable::Ownable;
+impl utils::ownable::OwnableInitializer for MyContract {}
+/// Implement the Ownable trait for the contract with default implementations.
+#[common_macros::contract_impl(contracttrait)]
+impl Ownable for MyContract {}