@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_receive_lib_for_eid.rs

@@ -11,7 +11,7 @@ fn test_require_receive_lib_for_eid_unregistered_lib() {
     let endpoint_client = &context.endpoint_client;
 
     let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid(env, &lib, context.eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, context.eid));
 }
 
 #[test]
@@ -24,7 +24,7 @@ fn test_require_receive_lib_for_eid_wrong_lib_type() {
     let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid(env, &lib, context.eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, context.eid));
 }
 
 #[test]
@@ -38,7 +38,7 @@ fn test_require_receive_lib_for_eid_unsupported_eid() {
     let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid(env, &lib, unsupported_eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid_for_test(env, &lib, unsupported_eid));
 }
 
 #[test]
@@ -50,12 +50,12 @@ fn test_require_receive_lib_for_eid_success_for_receive_and_send_and_receive() {
     let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
     context.register_library_with_auth(&receive_lib);
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::require_receive_lib_for_eid(env, &receive_lib, context.eid)
+        EndpointV2::require_receive_lib_for_eid_for_test(env, &receive_lib, context.eid)
     });
 
     let send_and_receive = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
     context.register_library_with_auth(&send_and_receive);
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::require_receive_lib_for_eid(env, &send_and_receive, context.eid)
+        EndpointV2::require_receive_lib_for_eid_for_test(env, &send_and_receive, context.eid)
     });
 }

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_registered.rs

@@ -15,7 +15,7 @@ fn test_require_registered_with_unregistered_lib() {
     let endpoint_client = &context.endpoint_client;
     let unregistered_lib = Address::generate(env);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_registered(env, &unregistered_lib));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_registered_for_test(env, &unregistered_lib));
 }
 
 #[test]
@@ -29,5 +29,5 @@ fn test_require_registered_with_registered_lib() {
     context.register_library_with_auth(&lib);
 
     // Should not panic
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_registered(env, &lib));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_registered_for_test(env, &lib));
 }

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_send_lib_for_eid.rs

@@ -11,7 +11,7 @@ fn test_require_send_lib_for_eid_unregistered_lib() {
     let endpoint_client = &context.endpoint_client;
 
     let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &lib, context.eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid_for_test(env, &lib, context.eid));
 }
 
 #[test]
@@ -24,7 +24,7 @@ fn test_require_send_lib_for_eid_wrong_lib_type() {
     let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &lib, context.eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid_for_test(env, &lib, context.eid));
 }
 
 #[test]
@@ -38,7 +38,7 @@ fn test_require_send_lib_for_eid_unsupported_eid() {
     let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
     context.register_library_with_auth(&lib);
 
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &lib, unsupported_eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid_for_test(env, &lib, unsupported_eid));
 }
 
 #[test]
@@ -49,11 +49,11 @@ fn test_require_send_lib_for_eid_success_for_send_and_send_and_receive() {
 
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
     context.register_library_with_auth(&send_lib);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &send_lib, context.eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid_for_test(env, &send_lib, context.eid));
 
     let send_and_receive = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
     context.register_library_with_auth(&send_and_receive);
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::require_send_lib_for_eid(env, &send_and_receive, context.eid)
+        EndpointV2::require_send_lib_for_eid_for_test(env, &send_and_receive, context.eid)
     });
 }

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_supported_eid.rs

@@ -10,7 +10,7 @@ fn test_require_supported_eid_with_supported() {
     let endpoint_client = &context.endpoint_client;
 
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid(env, &send_lib, context.eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid_for_test(env, &send_lib, context.eid));
 }
 
 // The require_supported_eid rejects when the library does not support the EID
@@ -23,7 +23,7 @@ fn test_require_supported_eid_with_unsupported() {
 
     let unsupported_eid = context.eid + 1;
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
-    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid(env, &send_lib, unsupported_eid));
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid_for_test(env, &send_lib, unsupported_eid));
 }
 
 // The require_supported_eid panics if the library address has no deployed contract
@@ -37,6 +37,6 @@ fn test_require_supported_eid_with_non_deployed_lib() {
     // Address that doesn't have a contract deployed
     let non_existent_lib = Address::generate(env);
     env.as_contract(&endpoint_client.address, || {
-        EndpointV2::require_supported_eid(env, &non_existent_lib, context.eid)
+        EndpointV2::require_supported_eid_for_test(env, &non_existent_lib, context.eid)
     });
 }

package/contracts/endpoint-v2/src/tests/messaging_channel/nilify.rs

@@ -10,7 +10,7 @@ use crate::{
 fn nil_hash(context: &TestSetup) -> BytesN<32> {
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
-    env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash(env))
+    env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash_for_test(env))
 }
 
 fn nilify_with_auth(

package/contracts/endpoint-v2/src/tests/messaging_composer/clear_compose.rs

@@ -2,11 +2,12 @@ use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
 use utils::testing_utils::assert_eq_event;
 
 use crate::{
-    constants::{MAX_COMPOSE_INDEX, RECEIVED_MESSAGE_HASH_BYTES},
     errors::EndpointError,
     events::ComposeDelivered,
-    tests::endpoint_setup::setup,
-    tests::endpoint_setup::TestSetup,
+    tests::{
+        endpoint_setup::{setup, TestSetup},
+        messaging_composer::{MAX_COMPOSE_INDEX, RECEIVED_MESSAGE_HASH_BYTES},
+    },
     util::keccak256,
 };
 

package/contracts/endpoint-v2/src/tests/messaging_composer/lz_compose_alert.rs

@@ -2,8 +2,13 @@ use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 use utils::testing_utils::assert_eq_event;
 
 use crate::{
-    constants::MAX_COMPOSE_INDEX, endpoint_v2::EndpointV2Client, errors::EndpointError, events::LzComposeAlert,
-    tests::endpoint_setup::setup, tests::endpoint_setup::TestSetup,
+    endpoint_v2::EndpointV2Client,
+    errors::EndpointError,
+    events::LzComposeAlert,
+    tests::{
+        endpoint_setup::{setup, TestSetup},
+        messaging_composer::MAX_COMPOSE_INDEX,
+    },
 };
 
 // Helpers

package/contracts/endpoint-v2/src/tests/messaging_composer/mod.rs

@@ -2,3 +2,7 @@ mod clear_compose;
 mod compose_queue;
 mod lz_compose_alert;
 mod send_compose;
+
+pub(crate) const MAX_COMPOSE_INDEX: u32 = u16::MAX as u32;
+pub(crate) const RECEIVED_MESSAGE_HASH_BYTES: [u8; 32] =
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];

package/contracts/endpoint-v2/src/tests/messaging_composer/send_compose.rs

@@ -2,8 +2,13 @@ use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
 use utils::testing_utils::assert_eq_event;
 
 use crate::{
-    constants::MAX_COMPOSE_INDEX, errors::EndpointError, events::ComposeSent, tests::endpoint_setup::setup,
-    tests::endpoint_setup::TestSetup, util::keccak256,
+    errors::EndpointError,
+    events::ComposeSent,
+    tests::{
+        endpoint_setup::{setup, TestSetup},
+        messaging_composer::MAX_COMPOSE_INDEX,
+    },
+    util::keccak256,
 };
 
 fn try_send_compose_with_auth(

package/contracts/layerzero-views/src/layerzero_view.rs

@@ -211,4 +211,3 @@ impl LayerZeroView {
         true
     }
 }
-

package/contracts/layerzero-views/src/tests/mod.rs

@@ -2,3 +2,4 @@
 
 mod layerzero_view_tests;
 mod setup;
+mod types_tests;

package/contracts/layerzero-views/src/tests/types_tests.rs

@@ -0,0 +1,31 @@
+//! Unit tests for types module helper functions.
+
+use soroban_sdk::{BytesN, Env};
+
+use crate::types::{empty_payload_hash, nil_payload_hash};
+
+// ============================================================================
+// empty_payload_hash tests
+// ============================================================================
+
+#[test]
+fn test_empty_payload_hash_returns_all_zeros() {
+    let env = Env::default();
+    let hash = empty_payload_hash(&env);
+
+    // Verify it matches the expected constant
+    assert_eq!(hash.to_array(), BytesN::from_array(&env, &[0u8; 32]));
+}
+
+// ============================================================================
+// nil_payload_hash tests
+// ============================================================================
+
+#[test]
+fn test_nil_payload_hash_returns_all_0xff() {
+    let env = Env::default();
+    let hash = nil_payload_hash(&env);
+
+    // Verify it matches the expected constant
+    assert_eq!(hash.to_array(), BytesN::from_array(&env, &[0xffu8; 32]));
+}

package/contracts/layerzero-views/src/types.rs

@@ -1,6 +1,5 @@
 //! Shared types for LayerZero view contracts.
 
-use endpoint_v2::constants::{EMPTY_PAYLOAD_HASH_BYTES, NIL_PAYLOAD_HASH_BYTES};
 use soroban_sdk::{contracttype, BytesN, Env};
 
 /// Represents the execution state of a cross-chain message.
@@ -41,10 +40,10 @@ pub enum VerificationState {
 
 /// Returns the empty payload hash as BytesN<32>.
 pub fn empty_payload_hash(env: &Env) -> BytesN<32> {
-    BytesN::from_array(env, &EMPTY_PAYLOAD_HASH_BYTES)
+    BytesN::from_array(env, &[0u8; 32])
 }
 
 /// Returns the nil payload hash as BytesN<32>.
 pub fn nil_payload_hash(env: &Env) -> BytesN<32> {
-    BytesN::from_array(env, &NIL_PAYLOAD_HASH_BYTES)
+    BytesN::from_array(env, &[0xffu8; 32])
 }

package/contracts/macro-integration-tests/tests/runtime/contract_ttl/constructor.rs

@@ -0,0 +1,61 @@
+// Runtime tests: `#[contract_impl]` injects default TTL config initialization into `__constructor`.
+//
+// This validates behavior end-to-end at runtime (not just snapshot tests):
+// - Registering a contract that defines `__constructor` should initialize default TTL configs
+//   via `utils::ttl_configurable::init_default_ttl_configs`.
+
+use soroban_sdk::{contract, Env};
+use utils::ttl_configurable::{TtlConfig, TtlConfigStorage, LEDGERS_PER_DAY};
+
+#[contract]
+pub struct CtorContract;
+
+#[common_macros::contract_impl]
+impl CtorContract {
+    // Constructor signature uses &Env to exercise the `env` (not `&env`) injection path.
+    pub fn __constructor(env: &Env) {
+        let _ = env;
+    }
+}
+
+#[test]
+fn constructor_initializes_default_ttl_configs() {
+    let env = Env::default();
+
+    // Registering with `()` will invoke `__constructor`.
+    let contract_id = env.register(CtorContract, ());
+
+    let (instance_cfg, persistent_cfg) = env.as_contract(&contract_id, || {
+        (TtlConfigStorage::instance(&env), TtlConfigStorage::persistent(&env))
+    });
+
+    let expected = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
+    assert_eq!(instance_cfg, Some(expected));
+    assert_eq!(persistent_cfg, Some(expected));
+}
+
+#[contract]
+pub struct CtorOwnedEnvContract;
+
+#[common_macros::contract_impl]
+impl CtorOwnedEnvContract {
+    // Owned Env to exercise the `&env` injection path.
+    pub fn __constructor(env: Env) {
+        let _ = env;
+    }
+}
+
+#[test]
+fn constructor_with_owned_env_initializes_default_ttl_configs() {
+    let env = Env::default();
+    let contract_id = env.register(CtorOwnedEnvContract, ());
+
+    let (instance_cfg, persistent_cfg) = env.as_contract(&contract_id, || {
+        (TtlConfigStorage::instance(&env), TtlConfigStorage::persistent(&env))
+    });
+
+    let expected = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
+    assert_eq!(instance_cfg, Some(expected));
+    assert_eq!(persistent_cfg, Some(expected));
+}
+

package/contracts/macro-integration-tests/tests/runtime/contract_ttl/contract_impl_ttl_extension.rs

@@ -0,0 +1,97 @@
+// Runtime tests: `#[contract_impl]` injects instance TTL extension.
+
+use soroban_sdk::{contract, testutils::storage::Instance as _, testutils::Ledger as _, Env};
+use utils::ttl_configurable::{TtlConfig, TtlConfigStorage};
+
+#[contract]
+pub struct TestContract;
+
+#[common_macros::contract_impl]
+impl TestContract {
+    pub fn ping(env: &Env) {
+        let _ = env;
+    }
+}
+
+#[test]
+fn ping_extends_instance_ttl_when_configured() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+
+    // Seed instance storage so TTL is present.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+
+    // Configure the injected TTL extension to always trigger and extend beyond current TTL.
+    let cfg = TtlConfig::new(10, before + 100);
+    env.as_contract(&contract_id, || {
+        TtlConfigStorage::set_instance(&env, &cfg);
+    });
+
+    // Force current TTL to be at/below threshold, then call ping.
+    env.ledger().set_sequence_number(live_until.saturating_sub(cfg.threshold));
+    let client = TestContractClient::new(&env, &contract_id);
+    client.ping();
+
+    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(after, cfg.extend_to);
+}
+
+#[test]
+fn ping_does_not_extend_instance_ttl_without_config() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+
+    // Seed instance storage so TTL is present.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    // Move ledger near expiry (would trigger if config existed).
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+    env.ledger().set_sequence_number(live_until.saturating_sub(1));
+
+    let ttl_before_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let client = TestContractClient::new(&env, &contract_id);
+    client.ping();
+    let ttl_after_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+
+    assert_eq!(ttl_after_call, ttl_before_call);
+}
+
+#[test]
+fn ping_does_not_extend_instance_ttl_when_above_threshold() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+
+    // Seed instance storage so TTL is present.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    let initial_ttl = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let initial_seq = env.ledger().sequence();
+    let live_until = initial_seq + initial_ttl;
+
+    // Configure auto extension, but keep remaining TTL strictly greater than threshold.
+    let cfg = TtlConfig::new(10, initial_ttl + 100);
+    env.as_contract(&contract_id, || {
+        TtlConfigStorage::set_instance(&env, &cfg);
+    });
+
+    env.ledger().set_sequence_number(live_until.saturating_sub(cfg.threshold.saturating_add(1)));
+    let ttl_before_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+
+    let client = TestContractClient::new(&env, &contract_id);
+    client.ping();
+
+    let ttl_after_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(ttl_after_call, ttl_before_call);
+}

package/contracts/macro-integration-tests/tests/runtime/contract_ttl/contract_trait_ttl_extension.rs

@@ -0,0 +1,99 @@
+// Runtime tests: `#[contract_trait]` injects instance TTL extension into default methods.
+
+use soroban_sdk::{contract, testutils::storage::Instance as _, testutils::Ledger as _, Env};
+use utils::ttl_configurable::{TtlConfig, TtlConfigStorage};
+
+#[common_macros::contract_trait]
+pub trait MyTrait {
+    fn ping(env: &Env) {
+        let _ = env;
+    }
+}
+
+#[contract]
+pub struct TestContract;
+
+#[soroban_sdk::contractimpl(contracttrait)]
+impl MyTrait for TestContract {}
+
+#[test]
+fn default_trait_method_extends_instance_ttl_when_configured() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Seed instance storage so TTL is present.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+
+    // Configure TTL extension.
+    let cfg = TtlConfig::new(10, before + 100);
+    env.as_contract(&contract_id, || {
+        TtlConfigStorage::set_instance(&env, &cfg);
+    });
+
+    env.ledger().set_sequence_number(live_until.saturating_sub(cfg.threshold));
+    client.ping();
+
+    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(after, cfg.extend_to);
+}
+
+#[test]
+fn default_trait_method_does_not_extend_instance_ttl_without_config() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Seed instance storage so TTL is present.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    // Move ledger near expiry (would trigger if config existed).
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+    env.ledger().set_sequence_number(live_until.saturating_sub(1));
+
+    let ttl_before_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    client.ping();
+    let ttl_after_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+
+    assert_eq!(ttl_after_call, ttl_before_call);
+}
+
+#[test]
+fn default_trait_method_does_not_extend_instance_ttl_when_above_threshold() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Seed instance storage so TTL is present.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    let initial_ttl = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let initial_seq = env.ledger().sequence();
+    let live_until = initial_seq + initial_ttl;
+
+    // Configure TTL extension, but keep remaining TTL strictly greater than threshold.
+    let cfg = TtlConfig::new(10, initial_ttl + 100);
+    env.as_contract(&contract_id, || {
+        TtlConfigStorage::set_instance(&env, &cfg);
+    });
+
+    env.ledger().set_sequence_number(live_until.saturating_sub(cfg.threshold.saturating_add(1)));
+    let ttl_before_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+
+    client.ping();
+
+    let ttl_after_call = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(ttl_after_call, ttl_before_call);
+}

package/contracts/macro-integration-tests/tests/runtime/contract_ttl/mod.rs

@@ -0,0 +1,3 @@
+mod contract_impl_ttl_extension;
+mod constructor;
+mod contract_trait_ttl_extension;

package/contracts/macro-integration-tests/tests/runtime/lz_contract/mod.rs

@@ -0,0 +1,5 @@
+mod wrapper_default;
+mod wrapper_multisig;
+mod wrapper_multisig_upgradeable;
+mod wrapper_upgradeable;
+mod wrapper_upgradeable_no_migration;

package/contracts/macro-integration-tests/tests/runtime/lz_contract/wrapper_default.rs

@@ -0,0 +1,86 @@
+// Runtime tests: `#[lz_contract]` wrapper macro (default options).
+
+use soroban_sdk::{
+    contractimpl,
+    testutils::{storage::Instance as _, Address as _, Ledger as _, MockAuth, MockAuthInvoke},
+    xdr::{ScErrorCode, ScErrorType},
+    Address, Env, Error, IntoVal,
+};
+use utils::ttl_configurable::TtlConfig;
+
+#[common_macros::lz_contract]
+pub struct TestContract;
+
+#[contractimpl]
+impl TestContract {
+    pub fn init(env: Env, owner: Address) {
+        Self::init_owner(&env, &owner);
+    }
+}
+
+#[test]
+fn exposes_ttl_and_ownable_features() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Ownable helper works.
+    let owner = Address::generate(&env);
+    client.init(&owner);
+    assert_eq!(client.authorizer(), owner);
+
+    // TTL-configurable read methods exist.
+    let _cfg = client.ttl_configs();
+    let _frozen = client.is_ttl_configs_frozen();
+
+    // ttl_extendable entry exists and extends instance TTL.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+
+    // Reduce current TTL to a small value, then extend to a known target.
+    env.ledger().set_sequence_number(live_until.saturating_sub(1));
+    client.extend_instance_ttl(&1, &50);
+
+    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(after, 50);
+}
+
+#[test]
+fn ttl_configurable_write_requires_owner_auth_and_roundtrips() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    let instance = Some(TtlConfig::new(1, 2));
+    let none: Option<TtlConfig> = None;
+
+    // Unauthorized set should fail.
+    let unauthorized = client.try_set_ttl_configs(&instance, &none);
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Authorized set should succeed and be readable back.
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_ttl_configs",
+                args: (&instance, &none).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .set_ttl_configs(&instance, &none);
+
+    assert_eq!(client.ttl_configs(), (instance, none));
+}

package/contracts/macro-integration-tests/tests/runtime/lz_contract/wrapper_multisig.rs

@@ -0,0 +1,47 @@
+// Runtime tests: `#[lz_contract(multisig)]` wrapper macro.
+
+use soroban_sdk::{
+    testutils::{storage::Instance as _, Ledger as _},
+    BytesN, Env, Vec,
+};
+
+#[common_macros::lz_contract(multisig)]
+pub struct MultisigLzContract;
+
+#[test]
+fn uses_self_owning_auth_and_exposes_ttl() {
+    let env = Env::default();
+    let contract_id = env.register(MultisigLzContract, ());
+    let client = MultisigLzContractClient::new(&env, &contract_id);
+
+    // MultiSig auth => authorizer should be the contract address, without any init.
+    let expected = env.as_contract(&contract_id, || env.current_contract_address());
+    assert_eq!(client.authorizer(), expected);
+
+    // TTL-configurable read methods exist.
+    let _cfg = client.ttl_configs();
+    let _frozen = client.is_ttl_configs_frozen();
+
+    // MultiSig view methods exist.
+    assert_eq!(client.threshold(), 0);
+    assert_eq!(client.total_signers(), 0);
+    let signer = BytesN::<20>::from_array(&env, &[1u8; 20]);
+    assert!(!client.is_signer(&signer));
+    let signers: Vec<BytesN<20>> = client.get_signers();
+    assert_eq!(signers.len(), 0);
+
+    // ttl_extendable entry exists and extends instance TTL.
+    env.as_contract(&contract_id, || {
+        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
+    });
+
+    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    let before_seq = env.ledger().sequence();
+    let live_until = before_seq + before;
+
+    env.ledger().set_sequence_number(live_until.saturating_sub(1));
+    client.extend_instance_ttl(&1, &50);
+
+    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(after, 50);
+}