@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,77 +0,0 @@
-// Runtime tests: `#[lz_contract(multisig, upgradeable)]` wrapper macro.
-//
-// This ensures upgradeability works under self-owning (multisig) authorization.
-
-use soroban_sdk::{
-    testutils::{storage::Instance as _, Ledger as _},
-    xdr::ToXdr,
-    xdr::{ScErrorCode, ScErrorType},
-    Env, Error, Val,
-};
-use utils::upgradeable::{UpgradeableInternal, UpgradeableStorage};
-
-#[common_macros::lz_contract(multisig, upgradeable)]
-pub struct MultisigUpgradeableLzContract;
-
-impl UpgradeableInternal for MultisigUpgradeableLzContract {
-    type MigrationData = Val;
-
-    fn __migrate(env: &Env, _migration_data: &Self::MigrationData) {
-        env.storage().instance().set(&soroban_sdk::Symbol::new(env, "migrated"), &true);
-    }
-}
-
-#[test]
-fn self_auth_can_migrate_when_flag_set() {
-    let env = Env::default();
-    let contract_id = env.register(MultisigUpgradeableLzContract, ());
-    let client = MultisigUpgradeableLzContractClient::new(&env, &contract_id);
-    let migration_data = Val::VOID.to_xdr(&env);
-
-    // MultiSig auth => authorizer should be the contract address, without any init.
-    let expected = env.as_contract(&contract_id, || env.current_contract_address());
-    assert_eq!(client.authorizer(), Some(expected));
-
-    // Unauthorized migrate should fail.
-    let unauthorized = client.try_migrate(&migration_data);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Enable self-auth for subsequent calls.
-    env.mock_all_auths();
-
-    // With auth, migrate without flag should fail with UpgradeableError.
-    let no_flag = client.try_migrate(&migration_data);
-    assert_eq!(no_flag.err().unwrap().ok().unwrap(), utils::errors::UpgradeableError::MigrationNotAllowed.into());
-
-    // Set migrating flag and migrate with self-auth should succeed.
-    env.as_contract(&contract_id, || {
-        UpgradeableStorage::set_migrating(&env, &true);
-    });
-
-    client.migrate(&migration_data);
-
-    env.as_contract(&contract_id, || {
-        assert_eq!(UpgradeableStorage::migrating(&env), false);
-        let migrated: Option<bool> = env.storage().instance().get(&soroban_sdk::Symbol::new(&env, "migrated"));
-        assert_eq!(migrated, Some(true));
-    });
-
-    // TTL-configurable read methods exist.
-    let _cfg = client.ttl_configs();
-    let _frozen = client.is_ttl_configs_frozen();
-
-    // ttl_extendable entry exists and extends instance TTL.
-    env.as_contract(&contract_id, || {
-        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
-    });
-    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    let before_seq = env.ledger().sequence();
-    let live_until = before_seq + before;
-    env.ledger().set_sequence_number(live_until.saturating_sub(1));
-    client.extend_instance_ttl(&1, &50);
-    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    assert_eq!(after, 50);
-}

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

@@ -1,114 +0,0 @@
-// Runtime tests: `#[lz_contract(upgradeable)]` wrapper macro.
-//
-// This ensures:
-// - ownable auth is present (owner-based)
-// - upgradeable entrypoints exist and are guarded by `only_auth`
-// - migrate obeys the migrating flag wiring
-
-use soroban_sdk::{
-    contractimpl,
-    testutils::{storage::Instance as _, Address as _, Ledger as _, MockAuth, MockAuthInvoke},
-    xdr::ToXdr,
-    xdr::{ScErrorCode, ScErrorType},
-    Address, Env, Error, IntoVal, Val,
-};
-use utils::upgradeable::{UpgradeableInternal, UpgradeableStorage};
-
-#[common_macros::lz_contract(upgradeable)]
-pub struct UpgradeableLzContract;
-
-impl UpgradeableInternal for UpgradeableLzContract {
-    type MigrationData = Val;
-
-    fn __migrate(env: &Env, _migration_data: &Self::MigrationData) {
-        env.storage().instance().set(&soroban_sdk::Symbol::new(env, "migrated"), &true);
-    }
-}
-
-#[contractimpl]
-impl UpgradeableLzContract {
-    pub fn init(env: Env, owner: Address) {
-        Self::init_owner(&env, &owner);
-    }
-}
-
-#[test]
-fn migrate_is_guarded_and_wired() {
-    let env = Env::default();
-    let contract_id = env.register(UpgradeableLzContract, ());
-    let client = UpgradeableLzContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-    let migration_data = Val::VOID.to_xdr(&env);
-
-    // Unauthorized migrate should fail.
-    let unauthorized = client.try_migrate(&migration_data);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized migrate without migrating flag should fail with UpgradeableError.
-    let result = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "migrate",
-                args: (&migration_data,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_migrate(&migration_data);
-    assert_eq!(result.err().unwrap().ok().unwrap(), utils::errors::UpgradeableError::MigrationNotAllowed.into());
-
-    // Set flag and migrate should succeed and clear the flag + run __migrate.
-    env.as_contract(&contract_id, || {
-        UpgradeableStorage::set_migrating(&env, &true);
-    });
-
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "migrate",
-                args: (&migration_data,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .migrate(&migration_data);
-
-    env.as_contract(&contract_id, || {
-        assert_eq!(UpgradeableStorage::migrating(&env), false);
-        let migrated: Option<bool> = env.storage().instance().get(&soroban_sdk::Symbol::new(&env, "migrated"));
-        assert_eq!(migrated, Some(true));
-    });
-}
-
-#[test]
-fn still_exposes_ttl_features() {
-    let env = Env::default();
-    let contract_id = env.register(UpgradeableLzContract, ());
-    let client = UpgradeableLzContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    // TTL-configurable read methods exist.
-    let _cfg = client.ttl_configs();
-    let _frozen = client.is_ttl_configs_frozen();
-
-    // ttl_extendable entry exists and extends instance TTL.
-    env.as_contract(&contract_id, || {
-        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
-    });
-    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    let before_seq = env.ledger().sequence();
-    let live_until = before_seq + before;
-    env.ledger().set_sequence_number(live_until.saturating_sub(1));
-    client.extend_instance_ttl(&1, &50);
-    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    assert_eq!(after, 50);
-}

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

@@ -1,105 +0,0 @@
-// Runtime tests: `#[lz_contract(upgradeable(no_migration))]` wrapper macro.
-//
-// This ensures:
-// - ownable auth is present (owner-based)
-// - upgradeable entrypoints exist without requiring manual UpgradeableInternal impl
-// - migrate obeys the migrating flag wiring (no-op migration)
-// - ttl_configurable + ttl_extendable are still present
-
-use soroban_sdk::{
-    contractimpl,
-    testutils::{storage::Instance as _, Address as _, Ledger as _, MockAuth, MockAuthInvoke},
-    xdr::ToXdr,
-    xdr::{ScErrorCode, ScErrorType},
-    Address, Env, Error, IntoVal, Val,
-};
-use utils::upgradeable::UpgradeableStorage;
-
-#[common_macros::lz_contract(upgradeable(no_migration))]
-pub struct NoMigrationUpgradeableLzContract;
-
-#[contractimpl]
-impl NoMigrationUpgradeableLzContract {
-    pub fn init(env: Env, owner: Address) {
-        Self::init_owner(&env, &owner);
-    }
-}
-
-#[test]
-fn migrate_is_guarded_and_noop_migration_works() {
-    let env = Env::default();
-    let contract_id = env.register(NoMigrationUpgradeableLzContract, ());
-    let client = NoMigrationUpgradeableLzContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-    let migration_data = Val::VOID.to_xdr(&env);
-
-    // Unauthorized migrate should fail.
-    let unauthorized = client.try_migrate(&migration_data);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized migrate without migrating flag should fail with UpgradeableError.
-    let no_flag = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "migrate",
-                args: (&migration_data,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_migrate(&migration_data);
-    assert_eq!(no_flag.err().unwrap().ok().unwrap(), utils::errors::UpgradeableError::MigrationNotAllowed.into());
-
-    // Set flag and migrate should succeed (no-op migration) and clear the flag.
-    env.as_contract(&contract_id, || {
-        UpgradeableStorage::set_migrating(&env, &true);
-    });
-
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "migrate",
-                args: (&migration_data,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .migrate(&migration_data);
-
-    env.as_contract(&contract_id, || {
-        assert_eq!(UpgradeableStorage::migrating(&env), false);
-    });
-}
-
-#[test]
-fn still_exposes_ttl_features() {
-    let env = Env::default();
-    let contract_id = env.register(NoMigrationUpgradeableLzContract, ());
-    let client = NoMigrationUpgradeableLzContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    // TTL-configurable read methods exist.
-    let _cfg = client.ttl_configs();
-    let _frozen = client.is_ttl_configs_frozen();
-
-    // ttl_extendable entry exists and extends instance TTL.
-    env.as_contract(&contract_id, || {
-        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "seed"), &true);
-    });
-    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    let before_seq = env.ledger().sequence();
-    let live_until = before_seq + before;
-    env.ledger().set_sequence_number(live_until.saturating_sub(1));
-    client.extend_instance_ttl(&1, &50);
-    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    assert_eq!(after, 50);
-}