@layerzerolabs/protocol-stellar-v2 0.2.22 → 0.2.23

package/contracts/macro-integration-tests/tests/runtime/ownable/ownership_transfer.rs

@@ -11,6 +11,8 @@ use soroban_sdk::{
     Address, Env, Error, IntoVal,
 };
 use utils::errors::OwnableError;
+use utils::ownable::{OwnershipRenounced, OwnershipTransferred};
+use utils::testing_utils::assert_eq_event;
 
 #[test]
 fn transfer_requires_auth() {
@@ -20,6 +22,7 @@ fn transfer_requires_auth() {
 
     let owner = Address::generate(&env);
     let new_owner = Address::generate(&env);
+    let third_owner = Address::generate(&env);
 
     client.init(&owner);
 
@@ -43,8 +46,51 @@ fn transfer_requires_auth() {
         }])
         .transfer_ownership(&new_owner);
 
+    assert_eq_event(
+        &env,
+        &contract_id,
+        OwnershipTransferred { old_owner: owner.clone(), new_owner: new_owner.clone() },
+    );
+
     // Owner should be updated
-    assert_eq!(client.owner(), Some(new_owner));
+    assert_eq!(client.owner(), Some(new_owner.clone()));
+
+    // Old owner should no longer be able to transfer ownership (even with auth).
+    let old_owner_transfer = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "transfer_ownership",
+                args: (&third_owner,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_transfer_ownership(&third_owner);
+    assert_eq!(
+        old_owner_transfer.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // New owner can transfer again.
+    client
+        .mock_auths(&[MockAuth {
+            address: &new_owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "transfer_ownership",
+                args: (&third_owner,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .transfer_ownership(&third_owner);
+
+    assert_eq_event(
+        &env,
+        &contract_id,
+        OwnershipTransferred { old_owner: new_owner.clone(), new_owner: third_owner.clone() },
+    );
+    assert_eq!(client.owner(), Some(third_owner));
 }
 
 #[test]
@@ -54,6 +100,7 @@ fn renounce_clears_owner() {
     let client = TestContractClient::new(&env, &contract_id);
 
     let owner = Address::generate(&env);
+    let not_owner = Address::generate(&env);
     client.init(&owner);
     assert_eq!(client.owner(), Some(owner.clone()));
 
@@ -64,6 +111,23 @@ fn renounce_clears_owner() {
         Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
     );
 
+    // Wrong-address auth should also fail (auth must be provided by the current owner).
+    let wrong_auth = client
+        .mock_auths(&[MockAuth {
+            address: &not_owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "renounce_ownership",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_renounce_ownership();
+    assert_eq!(
+        wrong_auth.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
     // Renounce ownership (authorized by current owner)
     client
         .mock_auths(&[MockAuth {
@@ -77,9 +141,14 @@ fn renounce_clears_owner() {
         }])
         .renounce_ownership();
 
+    assert_eq_event(&env, &contract_id, OwnershipRenounced { old_owner: owner.clone() });
+
     // Owner should be None after renouncing
     assert_eq!(client.owner(), None);
 
+    // Renouncing again should fail because there is no owner anymore.
+    assert_eq!(client.try_renounce_ownership().unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
+
     // All owner-protected operations should now fail
     let guarded_result = client
         .mock_auths(&[MockAuth {

package/contracts/macro-integration-tests/tests/runtime/ownable/two_step_transfer.rs

@@ -0,0 +1,219 @@
+// Runtime tests: 2-step ownership transfer behavior (`propose_ownership_transfer` + `accept_ownership`).
+//
+// Ownable supports a safer two-step flow using temporary storage with TTL. These tests ensure
+// the macro-exported contract entrypoints are wired and behave correctly at runtime.
+
+use super::{TestContract, TestContractClient};
+use soroban_sdk::{
+    testutils::{storage::Temporary as _, Address as _, Ledger as _, MockAuth, MockAuthInvoke},
+    Address, Env, IntoVal,
+};
+use utils::errors::OwnableError;
+use utils::ownable::{OwnableStorage, OwnershipTransferred, OwnershipTransferring};
+use utils::testing_utils::assert_eq_event;
+
+#[test]
+fn propose_requires_owner_auth() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    client.init(&owner);
+
+    // No auth provided -> should fail at require_auth.
+    let ttl = 10u32;
+    let res = client.try_propose_ownership_transfer(&new_owner, &ttl);
+    assert_eq!(
+        res.err().unwrap().ok().unwrap(),
+        soroban_sdk::Error::from_type_and_code(soroban_sdk::xdr::ScErrorType::Context, soroban_sdk::xdr::ScErrorCode::InvalidAction)
+    );
+}
+
+#[test]
+fn propose_rejects_invalid_ttl() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    client.init(&owner);
+
+    let ttl = env.storage().max_ttl().saturating_add(1);
+    let res = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "propose_ownership_transfer",
+                args: (&new_owner, &ttl).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_propose_ownership_transfer(&new_owner, &ttl);
+    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::InvalidTtl.into());
+    assert_eq!(client.pending_owner(), None);
+}
+
+#[test]
+fn propose_and_accept_transfers_ownership() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let new_owner = Address::generate(&env);
+    client.init(&owner);
+
+    // Propose transfer (owner auth required).
+    let ttl = 10u32;
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "propose_ownership_transfer",
+                args: (&new_owner, &ttl).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .propose_ownership_transfer(&new_owner, &ttl);
+
+    assert_eq_event(
+        &env,
+        &contract_id,
+        OwnershipTransferring { old_owner: owner.clone(), new_owner: new_owner.clone(), ttl },
+    );
+    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
+    assert_eq!(client.owner(), Some(owner.clone()));
+
+    // Accept transfer (pending owner auth required).
+    client
+        .mock_auths(&[MockAuth {
+            address: &new_owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "accept_ownership",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .accept_ownership();
+
+    assert_eq_event(
+        &env,
+        &contract_id,
+        OwnershipTransferred { old_owner: owner.clone(), new_owner: new_owner.clone() },
+    );
+    assert_eq!(client.pending_owner(), None);
+    assert_eq!(client.owner(), Some(new_owner));
+}
+
+#[test]
+fn pending_transfer_blocks_single_step_transfer_and_renounce() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let pending = Address::generate(&env);
+    let other = Address::generate(&env);
+    client.init(&owner);
+
+    let ttl = 10u32;
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "propose_ownership_transfer",
+                args: (&pending, &ttl).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .propose_ownership_transfer(&pending, &ttl);
+
+    // With owner auth, immediate transfer should fail due to TransferInProgress.
+    let transfer = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "transfer_ownership",
+                args: (&other,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_transfer_ownership(&other);
+    assert_eq!(transfer.err().unwrap().ok().unwrap(), OwnableError::TransferInProgress.into());
+
+    // With owner auth, renounce should also fail due to TransferInProgress.
+    let renounce = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "renounce_ownership",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_renounce_ownership();
+    assert_eq!(renounce.err().unwrap().ok().unwrap(), OwnableError::TransferInProgress.into());
+}
+
+#[test]
+fn pending_transfer_expires_and_cannot_be_accepted() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let pending = Address::generate(&env);
+    client.init(&owner);
+
+    let ttl = 1u32;
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "propose_ownership_transfer",
+                args: (&pending, &ttl).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .propose_ownership_transfer(&pending, &ttl);
+
+    assert_eq!(client.pending_owner(), Some(pending.clone()));
+
+    // Advance beyond the pending owner's *actual* temporary TTL so it expires.
+    // Note: `extend_ttl` does not shrink TTL, so `ttl` is not guaranteed to be the TTL.
+    let (pending_ttl, seq) = env.as_contract(&contract_id, || {
+        (env.storage().temporary().get_ttl(&OwnableStorage::PendingOwner), env.ledger().sequence())
+    });
+    let live_until = seq + pending_ttl;
+    env.ledger().set_sequence_number(live_until + 1);
+
+    assert_eq!(client.pending_owner(), None);
+
+    // Even with pending-owner auth, accept should fail because the transfer expired.
+    let res = client
+        .mock_auths(&[MockAuth {
+            address: &pending,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "accept_ownership",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_accept_ownership();
+    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::NoPendingTransfer.into());
+
+    // Owner should remain unchanged.
+    assert_eq!(client.owner(), Some(owner));
+}
+

package/contracts/macro-integration-tests/tests/runtime/storage/keyed_roundtrip.rs

@@ -59,6 +59,8 @@ fn single_field_keyed_all_storage_types() {
             // Initially absent
             assert_eq!(InstanceKeyed::value(&env, k1), None);
             assert_eq!(InstanceKeyed::value(&env, k2), None);
+            assert_eq!(InstanceKeyed::has_value(&env, k1), false);
+            assert_eq!(InstanceKeyed::has_value(&env, k2), false);
 
             // Set and verify isolation
             InstanceKeyed::set_value(&env, k1, &100);
@@ -66,6 +68,17 @@ fn single_field_keyed_all_storage_types() {
 
             assert_eq!(InstanceKeyed::value(&env, k1), Some(100));
             assert_eq!(InstanceKeyed::value(&env, k2), Some(200));
+            assert_eq!(InstanceKeyed::has_value(&env, k1), true);
+            assert_eq!(InstanceKeyed::has_value(&env, k2), true);
+
+            // set_or_remove for keyed instance storage
+            InstanceKeyed::set_or_remove_value(&env, k1, &Some(123));
+            assert_eq!(InstanceKeyed::value(&env, k1), Some(123));
+            assert_eq!(InstanceKeyed::has_value(&env, k1), true);
+
+            InstanceKeyed::set_or_remove_value(&env, k1, &None);
+            assert_eq!(InstanceKeyed::value(&env, k1), None);
+            assert_eq!(InstanceKeyed::has_value(&env, k1), false);
 
             // Remove k1, k2 unaffected
             InstanceKeyed::remove_value(&env, k1);
@@ -91,6 +104,15 @@ fn single_field_keyed_all_storage_types() {
             assert_eq!(PersistentKeyed::balance(&env, &k1), Some(111));
             assert_eq!(PersistentKeyed::balance(&env, &k2), Some(222));
 
+            // set_or_remove for keyed persistent storage
+            PersistentKeyed::set_or_remove_balance(&env, &k1, &Some(333));
+            assert_eq!(PersistentKeyed::balance(&env, &k1), Some(333));
+            assert_eq!(PersistentKeyed::has_balance(&env, &k1), true);
+
+            PersistentKeyed::set_or_remove_balance(&env, &k1, &None);
+            assert_eq!(PersistentKeyed::balance(&env, &k1), None);
+            assert_eq!(PersistentKeyed::has_balance(&env, &k1), false);
+
             // Remove k1, k2 unaffected
             PersistentKeyed::remove_balance(&env, &k1);
             assert_eq!(PersistentKeyed::has_balance(&env, &k1), false);
@@ -114,6 +136,16 @@ fn single_field_keyed_all_storage_types() {
             assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), true);
             assert_eq!(PersistentKeyed::balance_with_default(&env, &k), 111);
 
+            // set_or_remove(Some) updates value
+            PersistentKeyed::set_or_remove_balance_with_default(&env, &k, &Some(222));
+            assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), true);
+            assert_eq!(PersistentKeyed::balance_with_default(&env, &k), 222);
+
+            // set_or_remove(None) removes and returns to default
+            PersistentKeyed::set_or_remove_balance_with_default(&env, &k, &None);
+            assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), false);
+            assert_eq!(PersistentKeyed::balance_with_default(&env, &k), 999);
+
             // Removed: back to default, has_* is false
             PersistentKeyed::remove_balance_with_default(&env, &k);
             assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), false);
@@ -138,6 +170,15 @@ fn single_field_keyed_all_storage_types() {
             assert_eq!(TemporaryKeyed::flag(&env, &k1), Some(true));
             assert_eq!(TemporaryKeyed::flag(&env, &k2), Some(false));
 
+            // set_or_remove for keyed temporary storage
+            TemporaryKeyed::set_or_remove_flag(&env, &k1, &Some(false));
+            assert_eq!(TemporaryKeyed::flag(&env, &k1), Some(false));
+            assert_eq!(TemporaryKeyed::has_flag(&env, &k1), true);
+
+            TemporaryKeyed::set_or_remove_flag(&env, &k1, &None);
+            assert_eq!(TemporaryKeyed::flag(&env, &k1), None);
+            assert_eq!(TemporaryKeyed::has_flag(&env, &k1), false);
+
             // Remove k1, k2 unaffected
             TemporaryKeyed::remove_flag(&env, &k1);
             assert_eq!(TemporaryKeyed::flag(&env, &k1), None);

package/contracts/macro-integration-tests/tests/runtime/storage/ttl_extension.rs

@@ -11,7 +11,7 @@
 
 use soroban_sdk::{
     contract, contractimpl,
-    testutils::{storage::Instance as _, storage::Persistent as _, storage::Temporary as _, Ledger as _},
+    testutils::{storage::Persistent as _, storage::Temporary as _, Ledger as _},
     BytesN, Env,
 };
 use utils::ttl_configurable::{TtlConfig, TtlConfigStorage};
@@ -66,6 +66,32 @@ pub enum PersistentKeyNoTtl {
 mod auto_extension {
     use super::*;
 
+    #[test]
+    fn persistent_without_provider_does_not_auto_extend() {
+        let env = Env::default();
+        let contract_id = env.register(TestContract, ());
+        let k = BytesN::<32>::from_array(&env, &[7u8; 32]);
+
+        // Establish entry, but do NOT set any stored TTL config.
+        env.as_contract(&contract_id, || {
+            PersistentKeyWithTtl::set_balance(&env, &k, &1);
+        });
+
+        // Move ledger so TTL is small, then ensure get() doesn't extend without provider.
+        let (current_ttl, current_seq) = env.as_contract(&contract_id, || {
+            (env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone())), env.ledger().sequence())
+        });
+        let live_until = current_seq + current_ttl;
+        env.ledger().set_sequence_number(live_until.saturating_sub(1));
+
+        env.as_contract(&contract_id, || {
+            let ttl_before = env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone()));
+            let _ = PersistentKeyWithTtl::balance(&env, &k);
+            let ttl_after = env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone()));
+            assert_eq!(ttl_after, ttl_before);
+        });
+    }
+
     #[test]
     fn persistent_auto_ttl() {
         let env = Env::default();
@@ -183,6 +209,12 @@ mod auto_extension {
 mod manual_extend {
     use super::*;
 
+    #[common_macros::storage]
+    pub enum TemporaryKeyNoTtl {
+        #[temporary(u32)]
+        Counter,
+    }
+
     /// Tests manual TTL extension for all three storage types (instance, persistent, temporary).
     #[test]
     fn manual_extend_all_storage_types() {
@@ -190,21 +222,6 @@ mod manual_extend {
         let contract_id = env.register(TestContract, ());
         let k = BytesN::<32>::from_array(&env, &[1u8; 32]);
 
-        // --- Instance storage: extend_ttl(threshold, extend_to) - no key parameter ---
-        let (instance_ttl, instance_seq) = env.as_contract(&contract_id, || {
-            InstanceKeyWithTtl::set_counter(&env, &42);
-            (env.storage().instance().get_ttl(), env.ledger().sequence())
-        });
-        let instance_live_until = instance_seq + instance_ttl;
-        let instance_threshold = instance_ttl.saturating_sub(1);
-        let instance_extend_to = instance_ttl + 500;
-        env.ledger().set_sequence_number(instance_live_until - instance_threshold);
-        env.as_contract(&contract_id, || {
-            InstanceKeyWithTtl::extend_counter_ttl(&env, instance_threshold, instance_extend_to);
-            let updated_ttl = env.storage().instance().get_ttl();
-            assert_eq!(updated_ttl, instance_extend_to);
-        });
-
         // --- Persistent storage: extend_ttl(&key, threshold, extend_to) ---
         let (persistent_ttl, persistent_seq) = env.as_contract(&contract_id, || {
             PersistentKeyWithTtl::set_balance(&env, &k, &100);
@@ -234,6 +251,21 @@ mod manual_extend {
             let updated_ttl = env.storage().temporary().get_ttl(&TemporaryKeyWithTtl::Flag(k.clone()));
             assert_eq!(updated_ttl, temporary_extend_to);
         });
+
+        // --- Temporary storage (unit variant): extend_ttl(threshold, extend_to) ---
+        let (temporary_ttl, temporary_seq) = env.as_contract(&contract_id, || {
+            TemporaryKeyNoTtl::set_counter(&env, &42);
+            (env.storage().temporary().get_ttl(&TemporaryKeyNoTtl::Counter), env.ledger().sequence())
+        });
+        let temporary_live_until = temporary_seq + temporary_ttl;
+        let temporary_threshold = temporary_ttl.saturating_sub(1);
+        let temporary_extend_to = temporary_ttl + 123;
+        env.ledger().set_sequence_number(temporary_live_until - temporary_threshold);
+        env.as_contract(&contract_id, || {
+            TemporaryKeyNoTtl::extend_counter_ttl(&env, temporary_threshold, temporary_extend_to);
+            let updated_ttl = env.storage().temporary().get_ttl(&TemporaryKeyNoTtl::Counter);
+            assert_eq!(updated_ttl, temporary_extend_to);
+        });
     }
 
     /// Tests that manual TTL extension works even without a stored TTL config.

package/contracts/macro-integration-tests/tests/runtime/storage/unkeyed_roundtrip.rs

@@ -105,6 +105,16 @@ fn all_storage_types_unkeyed_roundtrip() {
             assert_eq!(PersistentKeyWithDefault::has_value(&env), true);
             assert_eq!(PersistentKeyWithDefault::value(&env), 100);
 
+            // set_or_remove(Some) updates value
+            PersistentKeyWithDefault::set_or_remove_value(&env, &Some(200));
+            assert_eq!(PersistentKeyWithDefault::has_value(&env), true);
+            assert_eq!(PersistentKeyWithDefault::value(&env), 200);
+
+            // set_or_remove(None) removes and returns to default
+            PersistentKeyWithDefault::set_or_remove_value(&env, &None);
+            assert_eq!(PersistentKeyWithDefault::has_value(&env), false);
+            assert_eq!(PersistentKeyWithDefault::value(&env), 42);
+
             // Remove value returns to default
             PersistentKeyWithDefault::remove_value(&env);
             assert_eq!(PersistentKeyWithDefault::has_value(&env), false);

package/contracts/macro-integration-tests/tests/runtime/ttl_configurable/configuration.rs

@@ -12,7 +12,9 @@ use soroban_sdk::{
     xdr::{ScErrorCode, ScErrorType},
     Address, Env, Error, IntoVal,
 };
-use utils::{errors::TtlConfigurableError, ttl_configurable::TtlConfig};
+use utils::testing_utils::assert_eq_event;
+use utils::ttl_configurable::TtlConfigsSet;
+use utils::{errors::{OwnableError, TtlConfigurableError}, ttl_configurable::TtlConfig};
 
 #[contract]
 #[ttl_configurable]
@@ -33,14 +35,14 @@ fn read_without_auth() {
     let client = TestContractClient::new(&env, &contract_id);
 
     // Read methods should be callable without initialization/auth
-    client.ttl_configs();
+    assert_eq!(client.ttl_configs(), (None, None));
     assert!(!client.is_ttl_configs_frozen());
 
     // Also works after owner initialization
     let owner = Address::generate(&env);
     client.init(&owner);
 
-    client.ttl_configs();
+    assert_eq!(client.ttl_configs(), (None, None));
     assert!(!client.is_ttl_configs_frozen());
 }
 
@@ -78,12 +80,72 @@ fn set_requires_auth() {
         }])
         .set_ttl_configs(&instance, &persistent);
 
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+
     // Config should be updated
     let after = client.ttl_configs();
     assert_ne!(before, after);
     assert_eq!(after, (instance, persistent));
 }
 
+#[test]
+fn set_before_init_fails_with_owner_not_set() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // No init() call => Ownable owner not set, so Auth::authorizer() fails.
+    let instance = Some(TtlConfig::new(1, 2));
+    let persistent = None::<TtlConfig>;
+    let err = client.try_set_ttl_configs(&instance, &persistent).unwrap_err().unwrap();
+    assert_eq!(err, OwnableError::OwnerNotSet.into());
+}
+
+#[test]
+fn set_and_remove_configs_roundtrip() {
+    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);
+
+    // Set both configs.
+    let instance = Some(TtlConfig::new(1, 2));
+    let persistent = Some(TtlConfig::new(3, 4));
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_ttl_configs",
+                args: (&instance, &persistent).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .set_ttl_configs(&instance, &persistent);
+
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+    assert_eq!(client.ttl_configs(), (instance, persistent));
+
+    // Remove (disable) both configs.
+    let none: Option<TtlConfig> = None::<TtlConfig>;
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_ttl_configs",
+                args: (&none, &none).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .set_ttl_configs(&none, &none);
+
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance: none, persistent: none });
+    assert_eq!(client.ttl_configs(), (None, None));
+}
+
 #[test]
 fn invalid_config_rejected() {
     let env = Env::default();
@@ -93,6 +155,8 @@ fn invalid_config_rejected() {
     let owner = Address::generate(&env);
     client.init(&owner);
 
+    let before = client.ttl_configs();
+
     // Invalid config: threshold > extend_to
     let invalid_instance = Some(TtlConfig::new(100, 50)); // threshold=100 > extend_to=50
     let none: Option<TtlConfig> = None::<TtlConfig>;
@@ -110,4 +174,33 @@ fn invalid_config_rejected() {
         .try_set_ttl_configs(&invalid_instance, &none);
 
     assert_eq!(result.unwrap_err().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
+    // Config should remain unchanged on validation failure.
+    assert_eq!(client.ttl_configs(), before);
+}
+
+#[test]
+fn invalid_max_ttl_rejected() {
+    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 invalid = Some(TtlConfig::new(1, u32::MAX));
+    let none: Option<TtlConfig> = None::<TtlConfig>;
+
+    let result = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_ttl_configs",
+                args: (&invalid, &none).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_set_ttl_configs(&invalid, &none);
+
+    assert_eq!(result.unwrap_err().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
 }

package/contracts/macro-integration-tests/tests/runtime/ttl_configurable/freeze.rs

@@ -12,6 +12,8 @@ use soroban_sdk::{
     xdr::{ScErrorCode, ScErrorType},
     Address, Env, Error, IntoVal,
 };
+use utils::testing_utils::assert_eq_event;
+use utils::ttl_configurable::TtlConfigsFrozen;
 use utils::{errors::TtlConfigurableError, ttl_configurable::TtlConfig};
 
 #[contract]
@@ -54,6 +56,8 @@ fn freeze_requires_auth() {
         }])
         .freeze_ttl_configs();
 
+    assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
+
     assert!(client.is_ttl_configs_frozen());
 }