@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

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

@@ -0,0 +1,101 @@
+// Runtime tests: Ownership transfer and renounce behavior.
+//
+// Tests covered:
+// - `transfer_ownership` requires current owner authorization.
+// - `renounce_ownership` clears owner and blocks further operations.
+
+use super::{TestContract, TestContractClient};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    xdr::{ScErrorCode, ScErrorType},
+    Address, Env, Error, IntoVal,
+};
+use utils::errors::OwnableError;
+
+#[test]
+fn transfer_requires_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);
+
+    // Unauthorized transfer should fail
+    let unauthorized = client.try_transfer_ownership(&new_owner);
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Authorized transfer should succeed
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "transfer_ownership",
+                args: (&new_owner,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .transfer_ownership(&new_owner);
+
+    // Owner should be updated
+    assert_eq!(client.owner(), Some(new_owner));
+}
+
+#[test]
+fn renounce_clears_owner() {
+    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);
+    assert_eq!(client.owner(), Some(owner.clone()));
+
+    // Unauthorized renounce should fail
+    let unauthorized = client.try_renounce_ownership();
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Renounce ownership (authorized by current owner)
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "renounce_ownership",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .renounce_ownership();
+
+    // Owner should be None after renouncing
+    assert_eq!(client.owner(), None);
+
+    // All owner-protected operations should now fail
+    let guarded_result = client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "guarded",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_guarded();
+    assert_eq!(guarded_result.unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
+
+    assert_eq!(
+        client.try_transfer_ownership(&Address::generate(&env)).unwrap_err().unwrap(),
+        OwnableError::OwnerNotSet.into()
+    );
+}

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

@@ -0,0 +1,225 @@
+// Runtime test: keyed (named field variant) roundtrip for all storage types.
+//
+// Purpose:
+// - Validates all three storage types (instance, persistent, temporary) work correctly
+//   with keyed variants (named fields).
+// - Validates key isolation: different keys map to distinct storage entries.
+// - Validates single-field and multi-field keyed variants.
+// - Complements unkeyed_roundtrip.rs for symmetric coverage.
+
+use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, BytesN, Env};
+
+#[contract]
+pub struct TestContract;
+
+#[contractimpl]
+impl TestContract {}
+
+// ============================================================================
+// Single-field keyed variants (all storage types)
+// ============================================================================
+
+#[common_macros::storage]
+pub enum InstanceKeyed {
+    #[instance(u32)]
+    Value { key: u32 },
+}
+
+#[common_macros::storage]
+pub enum PersistentKeyed {
+    #[persistent(i128)]
+    Balance { key: BytesN<32> },
+
+    // Keyed variant with a default value: getter should return the default when absent,
+    // while has_* remains false until an explicit set.
+    #[persistent(i128)]
+    #[default(999)]
+    BalanceWithDefault { key: BytesN<32> },
+}
+
+#[common_macros::storage]
+pub enum TemporaryKeyed {
+    #[temporary(bool)]
+    Flag { key: Address },
+}
+
+#[test]
+fn single_field_keyed_all_storage_types() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+
+    env.as_contract(&contract_id, || {
+        // ====================================================================
+        // Instance storage (keyed by primitive u32)
+        // ====================================================================
+        {
+            let k1: u32 = 1;
+            let k2: u32 = 2;
+
+            // Initially absent
+            assert_eq!(InstanceKeyed::value(&env, k1), None);
+            assert_eq!(InstanceKeyed::value(&env, k2), None);
+
+            // Set and verify isolation
+            InstanceKeyed::set_value(&env, k1, &100);
+            InstanceKeyed::set_value(&env, k2, &200);
+
+            assert_eq!(InstanceKeyed::value(&env, k1), Some(100));
+            assert_eq!(InstanceKeyed::value(&env, k2), Some(200));
+
+            // Remove k1, k2 unaffected
+            InstanceKeyed::remove_value(&env, k1);
+            assert_eq!(InstanceKeyed::value(&env, k1), None);
+            assert_eq!(InstanceKeyed::value(&env, k2), Some(200));
+        }
+
+        // ====================================================================
+        // Persistent storage (keyed by BytesN<32>)
+        // ====================================================================
+        {
+            let k1 = BytesN::<32>::from_array(&env, &[1u8; 32]);
+            let k2 = BytesN::<32>::from_array(&env, &[2u8; 32]);
+
+            // Initially absent
+            assert_eq!(PersistentKeyed::has_balance(&env, &k1), false);
+            assert_eq!(PersistentKeyed::has_balance(&env, &k2), false);
+
+            // Set and verify isolation
+            PersistentKeyed::set_balance(&env, &k1, &111);
+            PersistentKeyed::set_balance(&env, &k2, &222);
+
+            assert_eq!(PersistentKeyed::balance(&env, &k1), Some(111));
+            assert_eq!(PersistentKeyed::balance(&env, &k2), Some(222));
+
+            // Remove k1, k2 unaffected
+            PersistentKeyed::remove_balance(&env, &k1);
+            assert_eq!(PersistentKeyed::has_balance(&env, &k1), false);
+            assert_eq!(PersistentKeyed::balance(&env, &k1), None);
+            assert_eq!(PersistentKeyed::has_balance(&env, &k2), true);
+            assert_eq!(PersistentKeyed::balance(&env, &k2), Some(222));
+        }
+
+        // ====================================================================
+        // Persistent storage (keyed) with default value
+        // ====================================================================
+        {
+            let k = BytesN::<32>::from_array(&env, &[9u8; 32]);
+
+            // Absent: getter returns default, but has_* is false
+            assert_eq!(PersistentKeyed::balance_with_default(&env, &k), 999);
+            assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), false);
+
+            // Present: getter returns stored value, has_* is true
+            PersistentKeyed::set_balance_with_default(&env, &k, &111);
+            assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), true);
+            assert_eq!(PersistentKeyed::balance_with_default(&env, &k), 111);
+
+            // Removed: back to default, has_* is false
+            PersistentKeyed::remove_balance_with_default(&env, &k);
+            assert_eq!(PersistentKeyed::has_balance_with_default(&env, &k), false);
+            assert_eq!(PersistentKeyed::balance_with_default(&env, &k), 999);
+        }
+
+        // ====================================================================
+        // Temporary storage (keyed by Address)
+        // ====================================================================
+        {
+            let k1 = Address::generate(&env);
+            let k2 = Address::generate(&env);
+
+            // Initially absent
+            assert_eq!(TemporaryKeyed::flag(&env, &k1), None);
+            assert_eq!(TemporaryKeyed::flag(&env, &k2), None);
+
+            // Set and verify isolation
+            TemporaryKeyed::set_flag(&env, &k1, &true);
+            TemporaryKeyed::set_flag(&env, &k2, &false);
+
+            assert_eq!(TemporaryKeyed::flag(&env, &k1), Some(true));
+            assert_eq!(TemporaryKeyed::flag(&env, &k2), Some(false));
+
+            // Remove k1, k2 unaffected
+            TemporaryKeyed::remove_flag(&env, &k1);
+            assert_eq!(TemporaryKeyed::flag(&env, &k1), None);
+            assert_eq!(TemporaryKeyed::flag(&env, &k2), Some(false));
+        }
+    });
+}
+
+// ============================================================================
+// Multi-field keyed variant
+// ============================================================================
+
+#[common_macros::storage]
+pub enum MultiFieldKeyed {
+    #[persistent(i128)]
+    Balance { user: Address, token_id: u64 },
+}
+
+#[test]
+fn multi_field_keyed_isolation() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+
+    env.as_contract(&contract_id, || {
+        let user1 = Address::generate(&env);
+        let user2 = Address::generate(&env);
+        let token1: u64 = 1;
+        let token2: u64 = 2;
+
+        // Initially all absent
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token1), None);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token2), None);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token1), None);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token2), None);
+
+        // Set (user1, token1) only
+        MultiFieldKeyed::set_balance(&env, &user1, token1, &100);
+
+        // Only (user1, token1) should have value
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token1), Some(100));
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token2), None);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token1), None);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token2), None);
+
+        // Set more combinations
+        MultiFieldKeyed::set_balance(&env, &user1, token2, &200);
+        MultiFieldKeyed::set_balance(&env, &user2, token1, &300);
+
+        // Verify all three are independent
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token1), Some(100));
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token2), Some(200));
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token1), Some(300));
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token2), None);
+
+        // Remove (user1, token1) should not affect others
+        MultiFieldKeyed::remove_balance(&env, &user1, token1);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token1), None);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user1, token2), Some(200));
+        assert_eq!(MultiFieldKeyed::balance(&env, &user2, token1), Some(300));
+    });
+}
+
+#[test]
+fn multi_field_keyed_set_or_remove() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+
+    env.as_contract(&contract_id, || {
+        let user = Address::generate(&env);
+        let token: u64 = 42;
+
+        // has returns false when absent
+        assert_eq!(MultiFieldKeyed::has_balance(&env, &user, token), false);
+
+        // set_or_remove with Some sets value
+        MultiFieldKeyed::set_or_remove_balance(&env, &user, token, &Some(500));
+        assert_eq!(MultiFieldKeyed::has_balance(&env, &user, token), true);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user, token), Some(500));
+
+        // set_or_remove with None removes value
+        MultiFieldKeyed::set_or_remove_balance(&env, &user, token, &None);
+        assert_eq!(MultiFieldKeyed::has_balance(&env, &user, token), false);
+        assert_eq!(MultiFieldKeyed::balance(&env, &user, token), None);
+    });
+}

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

@@ -0,0 +1,4 @@
+mod keyed_roundtrip;
+mod name_override_runtime;
+mod ttl_extension;
+mod unkeyed_roundtrip;

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

@@ -0,0 +1,52 @@
+// Runtime test: #[name] attribute generates correct function names.
+//
+// Purpose:
+// - Validates that #[name("custom")] attribute generates functions with the custom name.
+// - Ensures the generated API (custom_counter, set_custom_counter, etc.) works at runtime.
+// - Complements UI test that only verifies compilation.
+
+use soroban_sdk::{contract, contractimpl, Env};
+
+#[common_macros::storage]
+pub enum StorageKey {
+    #[instance(u32)]
+    #[default(0)]
+    #[name("custom_counter")]
+    MyInternalCounter,
+}
+
+#[contract]
+pub struct MyContract;
+
+#[contractimpl]
+impl MyContract {}
+
+#[test]
+fn name_override_generates_correct_functions() {
+    let env = Env::default();
+    let contract_id = env.register(MyContract, ());
+
+    env.as_contract(&contract_id, || {
+        // Verify getter uses custom name (custom_counter, not my_internal_counter)
+        let v0 = StorageKey::custom_counter(&env);
+        assert_eq!(v0, 0); // default value
+
+        // Verify has uses custom name
+        assert_eq!(StorageKey::has_custom_counter(&env), false);
+
+        // Verify setter uses custom name
+        StorageKey::set_custom_counter(&env, &42);
+        assert_eq!(StorageKey::has_custom_counter(&env), true);
+        assert_eq!(StorageKey::custom_counter(&env), 42);
+
+        // Verify set_or_remove uses custom name
+        StorageKey::set_or_remove_custom_counter(&env, &Some(100));
+        assert_eq!(StorageKey::custom_counter(&env), 100);
+
+        // Verify remover uses custom name
+        StorageKey::remove_custom_counter(&env);
+        assert_eq!(StorageKey::has_custom_counter(&env), false);
+        assert_eq!(StorageKey::custom_counter(&env), 0); // back to default
+    });
+}
+

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

@@ -0,0 +1,261 @@
+// Runtime test: TTL extension behavior for all storage types.
+//
+// Purpose:
+// - Validates auto TTL extension triggered by get/has operations (persistent only, with stored config).
+// - Validates #[no_ttl_extension] disables auto TTL extension for persistent storage.
+// - Validates manual extend_ttl function works for all storage types.
+//
+// Key insight for TTL calculation:
+// - TTL = live_until_ledger - current_sequence
+// - To trigger auto extension, set sequence so TTL = threshold
+
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{storage::Instance as _, storage::Persistent as _, storage::Temporary as _, Ledger as _},
+    BytesN, Env,
+};
+use utils::ttl_configurable::{TtlConfig, TtlConfigStorage};
+
+#[contract]
+pub struct TestContract;
+
+#[contractimpl]
+impl TestContract {}
+
+// ============================================================================
+// Storage enums
+// ============================================================================
+
+#[common_macros::storage]
+pub enum InstanceKeyWithTtl {
+    #[instance(u32)]
+    #[default(0)]
+    Counter,
+}
+
+#[common_macros::storage]
+pub enum PersistentKeyWithTtl {
+    #[persistent(i128)]
+    Balance { key: BytesN<32> },
+
+    #[persistent(i128)]
+    #[no_ttl_extension]
+    BalanceNoAuto { key: BytesN<32> },
+}
+
+#[common_macros::storage]
+pub enum TemporaryKeyWithTtl {
+    #[temporary(bool)]
+    Flag { key: BytesN<32> },
+}
+
+// ============================================================================
+// Storage enum used to verify manual TTL extension without stored config
+// ============================================================================
+
+#[common_macros::storage]
+pub enum PersistentKeyNoTtl {
+    #[persistent(u32)]
+    Counter,
+}
+
+// ============================================================================
+// Tests: Auto TTL extension (persistent only)
+// ============================================================================
+
+mod auto_extension {
+    use super::*;
+
+    #[test]
+    fn persistent_auto_ttl() {
+        let env = Env::default();
+        let contract_id = env.register(TestContract, ());
+        let cfg = env.as_contract(&contract_id, || {
+            let cfg = TtlConfig::new(100, 110);
+            TtlConfigStorage::set_persistent(&env, &cfg);
+            cfg
+        });
+        let k = BytesN::<32>::from_array(&env, &[1u8; 32]);
+
+        // First write to establish entry
+        env.as_contract(&contract_id, || {
+            PersistentKeyWithTtl::set_balance(&env, &k, &1);
+        });
+
+        // Helper closure to test TTL trigger
+        let test_trigger = |action: &dyn Fn(&Env)| {
+            // Calculate live_until_ledger from current state
+            let current_seq = env.ledger().sequence();
+            let current_ttl = env.as_contract(&contract_id, || {
+                env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone()))
+            });
+            let live_until = current_seq + current_ttl;
+
+            // Set sequence so TTL = threshold
+            env.ledger().set_sequence_number(live_until - cfg.threshold);
+
+            env.as_contract(&contract_id, || {
+                action(&env);
+                assert_eq!(
+                    env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone())),
+                    cfg.extend_to
+                );
+            });
+        };
+
+        // Test get() triggers auto TTL extension
+        test_trigger(&|env| {
+            let _ = PersistentKeyWithTtl::balance(env, &k);
+        });
+
+        // Test has() triggers auto TTL extension
+        test_trigger(&|env| {
+            assert!(PersistentKeyWithTtl::has_balance(env, &k));
+        });
+
+        // Test set() triggers auto TTL extension (setter always appends auto-extend for persistent storage)
+        test_trigger(&|env| {
+            PersistentKeyWithTtl::set_balance(env, &k, &2);
+        });
+    }
+
+    #[test]
+    fn persistent_no_ttl_extension_respected() {
+        let env = Env::default();
+        let contract_id = env.register(TestContract, ());
+        let cfg = env.as_contract(&contract_id, || {
+            let cfg = TtlConfig::new(100, 110);
+            TtlConfigStorage::set_persistent(&env, &cfg);
+            cfg
+        });
+        let k = BytesN::<32>::from_array(&env, &[1u8; 32]);
+
+        let baseline_ttl = env.as_contract(&contract_id, || {
+            PersistentKeyWithTtl::set_balance_no_auto(&env, &k, &1);
+            env.storage().persistent().get_ttl(&PersistentKeyWithTtl::BalanceNoAuto(k.clone()))
+        });
+
+        env.ledger().set_sequence_number(baseline_ttl - cfg.threshold);
+
+        env.as_contract(&contract_id, || {
+            let _ = PersistentKeyWithTtl::balance_no_auto(&env, &k);
+            let _ = PersistentKeyWithTtl::has_balance_no_auto(&env, &k);
+            PersistentKeyWithTtl::set_balance_no_auto(&env, &k, &2);
+            assert_eq!(
+                env.storage().persistent().get_ttl(&PersistentKeyWithTtl::BalanceNoAuto(k.clone())),
+                cfg.threshold
+            );
+        });
+    }
+
+    #[test]
+    fn temporary_never_auto_ttl_extends() {
+        let env = Env::default();
+        let contract_id = env.register(TestContract, ());
+        let cfg = env.as_contract(&contract_id, || {
+            let cfg = TtlConfig::new(10, 40);
+            TtlConfigStorage::set_persistent(&env, &cfg);
+            TtlConfigStorage::set_instance(&env, &cfg);
+            cfg
+        });
+        let k = BytesN::<32>::from_array(&env, &[3u8; 32]);
+
+        let baseline_ttl = env.as_contract(&contract_id, || {
+            TemporaryKeyWithTtl::set_flag(&env, &k, &true);
+            env.storage().temporary().get_ttl(&TemporaryKeyWithTtl::Flag(k.clone()))
+        });
+
+        env.ledger().set_sequence_number(baseline_ttl - cfg.threshold);
+
+        env.as_contract(&contract_id, || {
+            let _ = TemporaryKeyWithTtl::flag(&env, &k);
+            let _ = TemporaryKeyWithTtl::has_flag(&env, &k);
+            TemporaryKeyWithTtl::set_flag(&env, &k, &false);
+            assert_eq!(env.storage().temporary().get_ttl(&TemporaryKeyWithTtl::Flag(k.clone())), cfg.threshold);
+        });
+    }
+}
+
+// ============================================================================
+// Tests: Manual TTL extension
+// ============================================================================
+
+mod manual_extend {
+    use super::*;
+
+    /// Tests manual TTL extension for all three storage types (instance, persistent, temporary).
+    #[test]
+    fn manual_extend_all_storage_types() {
+        let env = Env::default();
+        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);
+            (env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone())), env.ledger().sequence())
+        });
+        let persistent_live_until = persistent_seq + persistent_ttl;
+        let persistent_threshold = persistent_ttl.saturating_sub(1);
+        let persistent_extend_to = persistent_ttl + 200;
+        env.ledger().set_sequence_number(persistent_live_until - persistent_threshold);
+        env.as_contract(&contract_id, || {
+            PersistentKeyWithTtl::extend_balance_ttl(&env, &k, persistent_threshold, persistent_extend_to);
+            let updated_ttl = env.storage().persistent().get_ttl(&PersistentKeyWithTtl::Balance(k.clone()));
+            assert_eq!(updated_ttl, persistent_extend_to);
+        });
+
+        // --- Temporary storage: extend_ttl(&key, threshold, extend_to) ---
+        let (temporary_ttl, temporary_seq) = env.as_contract(&contract_id, || {
+            TemporaryKeyWithTtl::set_flag(&env, &k, &true);
+            (env.storage().temporary().get_ttl(&TemporaryKeyWithTtl::Flag(k.clone())), 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 + 100;
+        env.ledger().set_sequence_number(temporary_live_until - temporary_threshold);
+        env.as_contract(&contract_id, || {
+            TemporaryKeyWithTtl::extend_flag_ttl(&env, &k, temporary_threshold, temporary_extend_to);
+            let updated_ttl = env.storage().temporary().get_ttl(&TemporaryKeyWithTtl::Flag(k.clone()));
+            assert_eq!(updated_ttl, temporary_extend_to);
+        });
+    }
+
+    /// Tests that manual TTL extension works even without a stored TTL config.
+    #[test]
+    fn manual_extend_works_without_provider() {
+        let env = Env::default();
+        let contract_id = env.register(TestContract, ());
+
+        env.as_contract(&contract_id, || {
+            PersistentKeyNoTtl::set_counter(&env, &42);
+            let current_ttl = env.storage().persistent().get_ttl(&PersistentKeyNoTtl::Counter);
+            let current_seq = env.ledger().sequence();
+            let live_until = current_seq + current_ttl;
+
+            let threshold = current_ttl.saturating_sub(1);
+            let extend_to = current_ttl + 500;
+            env.ledger().set_sequence_number(live_until - threshold);
+
+            PersistentKeyNoTtl::extend_counter_ttl(&env, threshold, extend_to);
+
+            let updated_ttl = env.storage().persistent().get_ttl(&PersistentKeyNoTtl::Counter);
+            assert_eq!(updated_ttl, extend_to);
+        });
+    }
+}