@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.123

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

@@ -1,266 +0,0 @@
-// 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);
-            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);
-            InstanceKeyed::set_value(&env, k2, &200);
-
-            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);
-            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));
-
-            // 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);
-            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);
-
-            // 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);
-            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));
-
-            // 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);
-            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

@@ -1,4 +0,0 @@
-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

@@ -1,52 +0,0 @@
-// 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

@@ -1,293 +0,0 @@
-// 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::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_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();
-        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::*;
-
-    #[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() {
-        let env = Env::default();
-        let contract_id = env.register(TestContract, ());
-        let k = BytesN::<32>::from_array(&env, &[1u8; 32]);
-
-        // --- 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);
-        });
-
-        // --- 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.
-    #[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);
-        });
-    }
-}