@layerzerolabs/protocol-stellar-v2 0.2.22 → 0.2.23

package/contracts/utils/src/tests/ttl_configurable.rs

@@ -6,15 +6,13 @@ use crate::{
     option_ext::OptionExt,
     ownable::{Ownable, OwnableInitializer},
     testing_utils::assert_eq_event,
+    tests::test_helper::mock_auth,
     ttl_configurable::{
-        TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable, LEDGERS_PER_DAY, MAX_TTL,
+        init_default_ttl_configs, TtlConfig, TtlConfigStorage, TtlConfigsFrozen, TtlConfigsSet, TtlConfigurable,
+        LEDGERS_PER_DAY, MAX_TTL,
     },
 };
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Env, IntoVal,
-};
+use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, Env};
 
 const DEFAULT_INSTANCE_TTL: TtlConfig = TtlConfig::new(5 * LEDGERS_PER_DAY, 10 * LEDGERS_PER_DAY);
 const DEFAULT_PERSISTENT_TTL: TtlConfig = TtlConfig::new(5 * LEDGERS_PER_DAY, 10 * LEDGERS_PER_DAY);
@@ -92,6 +90,10 @@ impl TtlTestContract {
     pub fn is_ttl_configs_frozen(env: &Env) -> bool {
         <Self as TtlConfigurable>::is_ttl_configs_frozen(env)
     }
+
+    pub fn call_init_default_ttl_configs(env: &Env) {
+        init_default_ttl_configs(env);
+    }
 }
 
 // Enable the default `TtlConfigurable` implementation (which requires `Auth`) on the test contract.
@@ -118,19 +120,6 @@ fn setup_contract() -> (Env, Address, Address, TtlTestContractClient<'static>) {
     (env, contract_id, owner, client)
 }
 
-fn mock_auth<A: IntoVal<Env, soroban_sdk::Vec<soroban_sdk::Val>>>(
-    env: &Env,
-    contract_id: &Address,
-    address: &Address,
-    fn_name: &'static str,
-    args: A,
-) {
-    env.mock_auths(&[MockAuth {
-        address,
-        invoke: &MockAuthInvoke { contract: contract_id, args: args.into_val(env), fn_name, sub_invokes: &[] },
-    }]);
-}
-
 fn owner_set_ttl_configs(
     env: &Env,
     contract_id: &Address,
@@ -250,42 +239,35 @@ fn test_ttl_config_data_independent_storage() {
 }
 
 #[test]
-fn test_ttl_config_data_remove_all() {
+fn test_ttl_config_data_remove_when_not_set() {
     let (_, _, _owner, client) = setup_contract();
 
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    // Set all configs
-    client.set_instance_ttl(&instance_cfg);
-    client.set_persistent_ttl(&persistent_cfg);
-
-    // Verify all are set
-    assert!(client.has_instance_ttl());
-    assert!(client.has_persistent_ttl());
-
-    // Remove all
+    // Removing when not set should not panic
     client.remove_instance_ttl();
     client.remove_persistent_ttl();
 
-    // Verify all return to defaults
-    assert!(!client.has_instance_ttl());
-    assert!(!client.has_persistent_ttl());
+    // Should still return defaults
     assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
     assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
 }
 
 #[test]
-fn test_ttl_config_data_remove_when_not_set() {
+fn test_init_default_ttl_configs() {
     let (_, _, _owner, client) = setup_contract();
 
-    // Removing when not set should not panic
-    client.remove_instance_ttl();
-    client.remove_persistent_ttl();
+    // Initially no configs set
+    assert!(!client.has_instance_ttl());
+    assert!(!client.has_persistent_ttl());
 
-    // Should still return defaults
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
+    // Call init_default_ttl_configs
+    client.call_init_default_ttl_configs();
+
+    // Both should now be set to default values (29 days threshold, 30 days extend_to)
+    let expected_config = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
+    assert!(client.has_instance_ttl());
+    assert!(client.has_persistent_ttl());
+    assert_eq!(client.instance_ttl(), expected_config);
+    assert_eq!(client.persistent_ttl(), expected_config);
 }
 
 // ============================================
@@ -355,14 +337,15 @@ fn test_default_ttl_configurable_set_and_remove() {
     let instance = None;
     let persistent = Some(persistent_cfg);
     owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
     assert_eq!(client.configurable_ttl_configs(), (None, Some(persistent_cfg)));
 
-    // Remove by passing None
+    // Remove both by passing None
     let instance = None;
     let persistent = None;
     owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
-    assert!(client.configurable_ttl_configs().0.is_none());
-    assert!(client.configurable_ttl_configs().1.is_none());
+    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
+    assert_eq!(client.configurable_ttl_configs(), (None, None));
 }
 
 // ============================================
@@ -380,7 +363,24 @@ fn test_default_ttl_configurable_freeze() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1021)")] // TtlConfigFrozen
+fn test_default_ttl_configurable_freeze_preserves_configs() {
+    let (env, contract_id, owner, client) = setup_contract();
+
+    let instance_cfg = TtlConfig::new(1000, 2000);
+    let persistent_cfg = TtlConfig::new(3000, 4000);
+    let instance = Some(instance_cfg);
+    let persistent = Some(persistent_cfg);
+    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
+    assert_eq!(client.configurable_ttl_configs(), (Some(instance_cfg), Some(persistent_cfg)));
+
+    owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
+    assert!(client.is_ttl_configs_frozen());
+
+    // Freezing should not alter existing config values.
+    assert_eq!(client.configurable_ttl_configs(), (Some(instance_cfg), Some(persistent_cfg)));
+}
+
+#[test]
 fn test_default_ttl_configurable_set_when_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
@@ -389,17 +389,21 @@ fn test_default_ttl_configurable_set_when_frozen() {
     let instance_cfg = TtlConfig::new(1000, 2000);
     let instance = Some(instance_cfg);
     let persistent = None;
-    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
+    mock_auth(&env, &contract_id, &owner, "configurable_set_ttl_configs", (&instance, &persistent));
+    let res = client.try_configurable_set_ttl_configs(&instance, &persistent);
+    assert_eq!(res.err().unwrap().ok().unwrap(), TtlConfigurableError::TtlConfigFrozen.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1022)")] // TtlConfigAlreadyFrozen
 fn test_default_ttl_configurable_freeze_when_already_frozen() {
     let (env, contract_id, owner, client) = setup_contract();
 
     owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
     assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
-    owner_freeze_ttl_configs(&env, &contract_id, &owner, &client);
+
+    mock_auth(&env, &contract_id, &owner, "configurable_freeze_ttl_configs", ());
+    let res = client.try_configurable_freeze_ttl_configs();
+    assert_eq!(res.err().unwrap().ok().unwrap(), TtlConfigurableError::TtlConfigAlreadyFrozen.into());
 }
 
 #[test]
@@ -423,7 +427,6 @@ fn test_default_ttl_configurable_freeze_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn test_default_ttl_configurable_freeze_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -433,7 +436,8 @@ fn test_default_ttl_configurable_freeze_when_owner_not_set() {
 
     // Even with auth, `require_owner_auth` should fail because no owner is set in storage.
     mock_auth(&env, &contract_id, &owner, "configurable_freeze_ttl_configs", ());
-    client.configurable_freeze_ttl_configs();
+    let res = client.try_configurable_freeze_ttl_configs();
+    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
 }
 
 // ============================================
@@ -441,34 +445,26 @@ fn test_default_ttl_configurable_freeze_when_owner_not_set() {
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_invalid_instance_config() {
     let (env, contract_id, owner, client) = setup_contract();
     // threshold > extend_to is invalid
     let invalid_cfg = TtlConfig::new(3000, 2000);
     let instance = Some(invalid_cfg);
     let persistent = None;
-    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
+    mock_auth(&env, &contract_id, &owner, "configurable_set_ttl_configs", (&instance, &persistent));
+    let res = client.try_configurable_set_ttl_configs(&instance, &persistent);
+    assert_eq!(res.err().unwrap().ok().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_invalid_persistent_config() {
     let (env, contract_id, owner, client) = setup_contract();
     let invalid_cfg = TtlConfig::new(5000, 4000);
     let instance = None;
     let persistent = Some(invalid_cfg);
-    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
-fn test_default_ttl_configurable_exceeds_max_ttl() {
-    let (env, contract_id, owner, client) = setup_contract();
-    let invalid_cfg = TtlConfig::new(1000, MAX_TTL + 1);
-    let instance = Some(invalid_cfg);
-    let persistent = None;
-    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
+    mock_auth(&env, &contract_id, &owner, "configurable_set_ttl_configs", (&instance, &persistent));
+    let res = client.try_configurable_set_ttl_configs(&instance, &persistent);
+    assert_eq!(res.err().unwrap().ok().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
 }
 
 #[test]
@@ -529,7 +525,6 @@ fn test_default_ttl_configurable_set_wrong_signer_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1034)")] // OwnerNotSet
 fn test_default_ttl_configurable_set_when_owner_not_set() {
     let env = Env::default();
     let contract_id = env.register(TtlTestContract, ());
@@ -541,11 +536,11 @@ fn test_default_ttl_configurable_set_when_owner_not_set() {
 
     // Even with auth, `require_owner_auth` should fail because no owner is set in storage.
     mock_auth(&env, &contract_id, &owner, "configurable_set_ttl_configs", (&instance, &persistent));
-    client.configurable_set_ttl_configs(&instance, &persistent);
+    let res = client.try_configurable_set_ttl_configs(&instance, &persistent);
+    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::OwnerNotSet.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1020)")] // InvalidTtlConfig
 fn test_default_ttl_configurable_exceeds_effective_max_ttl() {
     let (env, contract_id, owner, client) = setup_contract();
 
@@ -554,30 +549,15 @@ fn test_default_ttl_configurable_exceeds_effective_max_ttl() {
     let instance = Some(TtlConfig::new(1, invalid_extend_to));
     let persistent = None;
 
-    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
+    mock_auth(&env, &contract_id, &owner, "configurable_set_ttl_configs", (&instance, &persistent));
+    let res = client.try_configurable_set_ttl_configs(&instance, &persistent);
+    assert_eq!(res.err().unwrap().ok().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
 }
 
 // ============================================
 // DefaultTtlConfigurable Tests - Boundary Values
 // ============================================
 
-#[test]
-fn test_default_ttl_configurable_at_max_ttl() {
-    let (env, contract_id, owner, client) = setup_contract();
-
-    // Get the effective max TTL
-    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
-
-    // extend_to == effective_max should be valid
-    let valid_cfg = TtlConfig::new(1000, effective_max);
-    let instance = Some(valid_cfg);
-    let persistent = None;
-    owner_set_ttl_configs(&env, &contract_id, &owner, &client, &instance, &persistent);
-
-    let (instance, _) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(valid_cfg));
-}
-
 #[test]
 fn test_default_ttl_configurable_boundary_values() {
     let (env, contract_id, owner, client) = setup_contract();

package/contracts/utils/src/tests/ttl_extendable.rs

@@ -0,0 +1,64 @@
+use crate::ttl_extendable::TtlExtendable;
+use soroban_sdk::{contract, contractimpl, testutils::storage::Instance as _, testutils::Ledger as _, Env};
+
+// ============================================
+// Test Contract for TtlExtendable
+// ============================================
+
+#[contract]
+pub struct TtlExtendableTestContract;
+
+#[contractimpl(contracttrait)]
+impl TtlExtendable for TtlExtendableTestContract {}
+
+// ============================================
+// TtlExtendable Tests
+// ============================================
+
+#[test]
+fn test_extend_instance_ttl_updates_instance_ttl() {
+    let env = Env::default();
+    let contract_id = env.register(TtlExtendableTestContract, ());
+    let client = TtlExtendableTestContractClient::new(&env, &contract_id);
+
+    // This is a minimal, high-signal assertion:
+    // verify we actually extended *instance* TTL via the Soroban host.
+    let (ttl_before, seq_before) =
+        env.as_contract(&contract_id, || (env.storage().instance().get_ttl(), env.ledger().sequence()));
+    let live_until = seq_before + ttl_before;
+    let threshold = ttl_before.saturating_sub(1);
+    let extend_to = ttl_before + 500;
+
+    // Move ledger sequence so TTL is below threshold, ensuring extension triggers.
+    env.ledger().set_sequence_number(live_until - threshold);
+
+    client.extend_instance_ttl(&threshold, &extend_to);
+
+    let ttl_after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(ttl_after, extend_to);
+}
+
+#[test]
+fn test_extend_instance_ttl_noop_when_above_threshold() {
+    let env = Env::default();
+    let contract_id = env.register(TtlExtendableTestContract, ());
+    let client = TtlExtendableTestContractClient::new(&env, &contract_id);
+
+    // First, force an extension so we have a known positive TTL baseline.
+    let (ttl_before, seq_before) =
+        env.as_contract(&contract_id, || (env.storage().instance().get_ttl(), env.ledger().sequence()));
+    let live_until = seq_before + ttl_before;
+    let threshold = ttl_before.saturating_sub(1);
+    let extend_to = ttl_before + 500;
+    env.ledger().set_sequence_number(live_until - threshold);
+    client.extend_instance_ttl(&threshold, &extend_to);
+    let ttl_after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(ttl_after, extend_to);
+
+    // Now call again with a threshold below the current TTL; it should NOT extend further.
+    let threshold = ttl_after.saturating_sub(1);
+    let extend_to_2 = ttl_after + 500;
+    client.extend_instance_ttl(&threshold, &extend_to_2);
+    let ttl_after_2 = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(ttl_after_2, ttl_after);
+}

package/contracts/utils/src/tests/upgradeable.rs

@@ -1,3 +1,4 @@
+use crate::errors::UpgradeableError;
 use crate::upgradeable::{Upgradeable, UpgradeableInternal, UpgradeableStorage};
 use soroban_sdk::{contract, contractimpl, xdr::ToXdr, Address, Bytes, Env, Symbol, Val};
 
@@ -334,6 +335,28 @@ impl UpgradeableInternal for DummyContract {
 #[contractimpl(contracttrait)]
 impl Upgradeable for DummyContract {}
 
+// Same as DummyContract but with a strict migration payload type so we can
+// exercise the InvalidMigrationData error path in Upgradeable::migrate.
+#[contract]
+pub struct U32MigrationContract;
+
+impl Auth for U32MigrationContract {
+    fn authorizer(env: &Env) -> Address {
+        env.current_contract_address()
+    }
+}
+
+impl UpgradeableInternal for U32MigrationContract {
+    type MigrationData = u32;
+
+    fn __migrate(env: &Env, migration_data: &Self::MigrationData) {
+        env.storage().instance().set(&Symbol::new(env, "migrated_u32"), migration_data);
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl Upgradeable for U32MigrationContract {}
+
 #[test]
 fn test_upgrade_success() {
     let env = Env::default();
@@ -358,6 +381,20 @@ fn test_upgrade_success() {
     });
 }
 
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_upgrade_requires_auth() {
+    let env = Env::default();
+    // Note: NOT calling mock_all_auths() - auth will fail
+    let contract_id = env.register(DummyContract, ());
+    let client = DummyContractClient::new(&env, &contract_id);
+
+    // Upload valid contract WASM to get a valid hash
+    let wasm_hash = env.deployer().upload_contract_wasm(Bytes::from_slice(&env, TEST_WASM));
+
+    client.upgrade(&wasm_hash);
+}
+
 // After upgrade(), the contract runs TEST_WASM code, so migrate() must match that wasm's API.
 #[test]
 fn test_migrate_success() {
@@ -384,7 +421,77 @@ fn test_migrate_success() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1051)")] // MigrationNotAllowed
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_migrate_requires_auth() {
+    let env = Env::default();
+    // Note: NOT calling mock_all_auths() - auth will fail
+    let contract_id = env.register(DummyContract, ());
+    let client = DummyContractClient::new(&env, &contract_id);
+
+    // Set the migrating flag so we know failure is due to auth, not MigrationNotAllowed.
+    env.as_contract(&contract_id, || {
+        UpgradeableStorage::set_migrating(&env, &true);
+        assert_eq!(UpgradeableStorage::migrating(&env), true);
+    });
+
+    let migration_data = Val::VOID.to_xdr(&env);
+    client.migrate(&migration_data);
+}
+
+#[test]
+fn test_migrate_rejects_invalid_migration_data_and_does_not_clear_flag() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let contract_id = env.register(U32MigrationContract, ());
+    let client = U32MigrationContractClient::new(&env, &contract_id);
+
+    // Allow migrate (so we hit the decode path rather than MigrationNotAllowed).
+    env.as_contract(&contract_id, || {
+        UpgradeableStorage::set_migrating(&env, &true);
+        assert_eq!(UpgradeableStorage::migrating(&env), true);
+    });
+
+    // Valid XDR, but not a u32 payload => should fail decoding in Upgradeable::migrate.
+    let bad_bytes = Val::VOID.to_xdr(&env);
+    let res = client.try_migrate(&bad_bytes);
+    assert_eq!(res.err().unwrap().ok().unwrap(), UpgradeableError::InvalidMigrationData.into());
+
+    // Since migration failed before reaching the "clear flag" line, migrating should still be true.
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), true);
+    });
+}
+
+#[test]
+fn test_can_upgrade_and_migrate_multiple_times() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let contract_id = env.register(DummyContract, ());
+    let client = DummyContractClient::new(&env, &contract_id);
+
+    let wasm_hash = env.deployer().upload_contract_wasm(Bytes::from_slice(&env, TEST_WASM));
+    let migration_data = Val::VOID.to_xdr(&env);
+
+    // First cycle
+    client.upgrade(&wasm_hash);
+    client.migrate(&migration_data);
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), false);
+        let stored_value: Option<bool> = env.storage().instance().get(&Symbol::new(&env, "migrated"));
+        assert_eq!(stored_value, Some(true));
+    });
+
+    // Second cycle (must be allowed)
+    client.upgrade(&wasm_hash);
+    client.migrate(&migration_data);
+    env.as_contract(&contract_id, || {
+        assert_eq!(UpgradeableStorage::migrating(&env), false);
+        let stored_value: Option<bool> = env.storage().instance().get(&Symbol::new(&env, "migrated"));
+        assert_eq!(stored_value, Some(true));
+    });
+}
+
+#[test]
 fn test_migrate_fail_without_upgrade() {
     let env = Env::default();
     env.mock_all_auths();
@@ -394,7 +501,8 @@ fn test_migrate_fail_without_upgrade() {
     // Try to migrate without setting migrating flag first
     // Should panic with MigrationNotAllowed
     let migration_data = Val::VOID.to_xdr(&env);
-    client.migrate(&migration_data);
+    let result = client.try_migrate(&migration_data);
+    assert_eq!(result.err().unwrap().ok().unwrap(), UpgradeableError::MigrationNotAllowed.into());
 }
 
 // ============================================
@@ -402,7 +510,6 @@ fn test_migrate_fail_without_upgrade() {
 // ============================================
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1051)")] // MigrationNotAllowed
 fn test_cannot_migrate_twice_without_upgrade() {
     let env = Env::default();
     env.mock_all_auths();
@@ -417,7 +524,8 @@ fn test_cannot_migrate_twice_without_upgrade() {
     client.migrate(&migration_data);
 
     // Try to migrate again without upgrade - should panic
-    client.migrate(&migration_data);
+    let result = client.try_migrate(&migration_data);
+    assert_eq!(result.err().unwrap().ok().unwrap(), UpgradeableError::MigrationNotAllowed.into());
 }
 
 // ============================================
@@ -460,18 +568,19 @@ fn test_upgrade_fails_when_frozen() {
 }
 
 #[test]
+#[should_panic(expected = "Error(Contract, #1052)")] // UpgradesFrozen
 fn test_freeze_multiple_times() {
     let env = Env::default();
     env.mock_all_auths();
     let contract_id = env.register(DummyContract, ());
     let client = DummyContractClient::new(&env, &contract_id);
 
-    // Freeze multiple times - should not panic
+    // First freeze should succeed
     client.freeze();
     assert_eq!(client.is_frozen(), true);
 
+    // Second freeze should panic with UpgradesFrozen
     client.freeze();
-    assert_eq!(client.is_frozen(), true);
 }
 
 #[test]

package/contracts/utils/src/ttl_configurable.rs

@@ -1,10 +1,6 @@
-use crate::{
-    self as utils,
-    auth::{self, Auth},
-    errors::TtlConfigurableError,
-};
-use common_macros::contract_trait;
-use soroban_sdk::{assert_with_error, contractevent, contracttype, Env};
+use crate::{self as utils, auth::Auth, errors::TtlConfigurableError};
+use common_macros::{contract_trait, only_auth, storage};
+use soroban_sdk::{assert_with_error, contractevent, contracttype, Env, IntoVal, Val};
 
 /// Ledgers per day (~5 second close time).
 pub const LEDGERS_PER_DAY: u32 = (24 * 3600) / 5;
@@ -64,7 +60,7 @@ pub struct TtlConfigsFrozen {}
 /// Note: Auto-TTL extension is disabled for these instance storage entries to avoid infinite
 /// recursion. Extending TTL config storage would require reading the TTL config, which would
 /// trigger another extension, creating a deep loop.
-#[common_macros::storage]
+#[storage]
 pub enum TtlConfigStorage {
     #[instance(bool)]
     #[default(false)]
@@ -86,6 +82,20 @@ pub fn init_default_ttl_configs(env: &Env) {
     TtlConfigStorage::set_persistent(env, &default_ttl_config);
 }
 
+/// Extends instance storage TTL using the configured settings (if any).
+pub fn extend_instance_ttl(env: &Env) {
+    if let Some(TtlConfig { threshold, extend_to }) = TtlConfigStorage::instance(env) {
+        env.storage().instance().extend_ttl(threshold, extend_to);
+    }
+}
+
+/// Extends persistent storage TTL for a key using the configured settings (if any).
+pub fn extend_persistent_ttl<K: IntoVal<Env, Val>>(env: &Env, key: &K) {
+    if let Some(TtlConfig { threshold, extend_to }) = TtlConfigStorage::persistent(env) {
+        env.storage().persistent().extend_ttl(key, threshold, extend_to);
+    }
+}
+
 /// Trait for contracts that support configurable TTL (Time-To-Live) management.
 ///
 /// Allows the contract authorizer to configure how long instance and persistent storage entries
@@ -96,7 +106,7 @@ pub fn init_default_ttl_configs(env: &Env) {
 ///
 /// Requires the `Auth` trait to be implemented, which can be provided by either:
 /// - `#[ownable]` macro for single-owner contracts
-/// - `Multisig` trait for multisig-controlled contracts
+/// - `#[multisig]` macro for multisig-controlled contracts
 #[contract_trait]
 pub trait TtlConfigurable: Auth {
     /// Sets TTL configs for instance and persistent storage.
@@ -111,15 +121,15 @@ pub trait TtlConfigurable: Auth {
     /// # Panics
     /// - `TtlConfigFrozen` if configs are frozen
     /// - `InvalidTtlConfig` if validation fails
+    #[only_auth]
     fn set_ttl_configs(
         env: &soroban_sdk::Env,
         instance: &Option<utils::ttl_configurable::TtlConfig>,
         persistent: &Option<utils::ttl_configurable::TtlConfig>,
     ) {
-        auth::require_auth::<Self>(env);
         assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlConfigurableError::TtlConfigFrozen);
 
-        let max_ttl = u32::min(MAX_TTL, env.storage().max_ttl());
+        let max_ttl = MAX_TTL.min(env.storage().max_ttl());
         let all_valid = [instance, persistent].iter().all(|c| c.is_none_or(|cfg| cfg.is_valid(max_ttl)));
         assert_with_error!(env, all_valid, TtlConfigurableError::InvalidTtlConfig);
 
@@ -143,8 +153,8 @@ pub trait TtlConfigurable: Auth {
     ///
     /// # Panics
     /// - `TtlConfigAlreadyFrozen` if already frozen
+    #[only_auth]
     fn freeze_ttl_configs(env: &soroban_sdk::Env) {
-        auth::require_auth::<Self>(env);
         assert_with_error!(env, !Self::is_ttl_configs_frozen(env), TtlConfigurableError::TtlConfigAlreadyFrozen);
 
         TtlConfigStorage::set_frozen(env, &true);

package/contracts/utils/src/ttl_extendable.rs

@@ -3,8 +3,6 @@
 //! This module provides the `TtlExtendable` trait which allows external callers
 //! to extend a contract's instance storage TTL, keeping the contract alive.
 
-use soroban_sdk::Env;
-
 /// Trait for contracts that support manual instance TTL extension.
 ///
 /// This trait provides a public contract function to extend the instance storage TTL,
@@ -21,7 +19,7 @@ pub trait TtlExtendable {
     ///
     /// * `threshold` - The threshold to extend the TTL (if current TTL is below this, extend).
     /// * `extend_to` - The TTL to extend to.
-    fn extend_instance_ttl(env: &Env, threshold: u32, extend_to: u32) {
+    fn extend_instance_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
         env.storage().instance().extend_ttl(threshold, extend_to);
     }
 }