@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

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

@@ -1,147 +0,0 @@
-// Runtime test: unkeyed (unit variant) roundtrip for all storage types.
-//
-// Purpose:
-// - Validates all three storage types (instance, persistent, temporary) work correctly
-//   with unit variants (no key fields).
-// - Validates complete lifecycle: set -> has -> get -> remove -> get returns default/None.
-// - Validates default attribute behavior.
-
-use soroban_sdk::{contract, contractimpl, Env};
-
-#[common_macros::storage]
-pub enum InstanceKey {
-    #[instance(u32)]
-    #[default(0)]
-    Counter,
-}
-
-#[common_macros::storage]
-pub enum PersistentKey {
-    #[persistent(u64)]
-    Counter,
-}
-
-#[common_macros::storage]
-pub enum PersistentKeyWithDefault {
-    #[persistent(u64)]
-    #[default(42)]
-    Value,
-}
-
-#[common_macros::storage]
-pub enum TemporaryKey {
-    #[temporary(bool)]
-    Flag,
-}
-
-#[contract]
-pub struct TestContract;
-
-#[contractimpl]
-impl TestContract {}
-
-#[test]
-fn all_storage_types_unkeyed_roundtrip() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-
-    env.as_contract(&contract_id, || {
-        // ====================================================================
-        // Instance storage (with default)
-        // ====================================================================
-        {
-            // Default when not set
-            assert_eq!(InstanceKey::counter(&env), 0);
-            assert_eq!(InstanceKey::has_counter(&env), false);
-
-            // Set value
-            InstanceKey::set_counter(&env, &5);
-            assert_eq!(InstanceKey::has_counter(&env), true);
-            assert_eq!(InstanceKey::counter(&env), 5);
-
-            // set_or_remove with Some updates value
-            InstanceKey::set_or_remove_counter(&env, &Some(10));
-            assert_eq!(InstanceKey::counter(&env), 10);
-
-            // set_or_remove with None removes value
-            InstanceKey::set_or_remove_counter(&env, &None);
-            assert_eq!(InstanceKey::has_counter(&env), false);
-            assert_eq!(InstanceKey::counter(&env), 0);
-        }
-
-        // ====================================================================
-        // Persistent storage (without default)
-        // ====================================================================
-        {
-            // Initially absent, returns None
-            assert_eq!(PersistentKey::counter(&env), None);
-            assert_eq!(PersistentKey::has_counter(&env), false);
-
-            // set_or_remove with Some sets value
-            PersistentKey::set_or_remove_counter(&env, &Some(100));
-            assert_eq!(PersistentKey::has_counter(&env), true);
-            assert_eq!(PersistentKey::counter(&env), Some(100));
-
-            // Update value
-            PersistentKey::set_counter(&env, &200);
-            assert_eq!(PersistentKey::counter(&env), Some(200));
-
-            // set_or_remove with None removes value
-            PersistentKey::set_or_remove_counter(&env, &None);
-            assert_eq!(PersistentKey::has_counter(&env), false);
-            assert_eq!(PersistentKey::counter(&env), None);
-        }
-
-        // ====================================================================
-        // Persistent storage (with default)
-        // ====================================================================
-        {
-            // Returns default value when not set
-            assert_eq!(PersistentKeyWithDefault::value(&env), 42);
-            assert_eq!(PersistentKeyWithDefault::has_value(&env), false);
-
-            // Set value overrides default
-            PersistentKeyWithDefault::set_value(&env, &100);
-            assert_eq!(PersistentKeyWithDefault::has_value(&env), true);
-            assert_eq!(PersistentKeyWithDefault::value(&env), 100);
-
-            // set_or_remove(Some) updates value
-            PersistentKeyWithDefault::set_or_remove_value(&env, &Some(200));
-            assert_eq!(PersistentKeyWithDefault::has_value(&env), true);
-            assert_eq!(PersistentKeyWithDefault::value(&env), 200);
-
-            // set_or_remove(None) removes and returns to default
-            PersistentKeyWithDefault::set_or_remove_value(&env, &None);
-            assert_eq!(PersistentKeyWithDefault::has_value(&env), false);
-            assert_eq!(PersistentKeyWithDefault::value(&env), 42);
-
-            // Remove value returns to default
-            PersistentKeyWithDefault::remove_value(&env);
-            assert_eq!(PersistentKeyWithDefault::has_value(&env), false);
-            assert_eq!(PersistentKeyWithDefault::value(&env), 42);
-        }
-
-        // ====================================================================
-        // Temporary storage (without default)
-        // ====================================================================
-        {
-            // Initially absent, returns None
-            assert_eq!(TemporaryKey::flag(&env), None);
-            assert_eq!(TemporaryKey::has_flag(&env), false);
-
-            // set_or_remove with Some sets value
-            TemporaryKey::set_or_remove_flag(&env, &Some(true));
-            assert_eq!(TemporaryKey::has_flag(&env), true);
-            assert_eq!(TemporaryKey::flag(&env), Some(true));
-
-            // Update value
-            TemporaryKey::set_flag(&env, &false);
-            assert_eq!(TemporaryKey::flag(&env), Some(false));
-
-            // set_or_remove with None removes value
-            TemporaryKey::set_or_remove_flag(&env, &None);
-            assert_eq!(TemporaryKey::has_flag(&env), false);
-            assert_eq!(TemporaryKey::flag(&env), None);
-        }
-    });
-}

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

@@ -1,206 +0,0 @@
-// Runtime tests: TTL configuration read/write behavior.
-//
-// Tests covered:
-// - `ttl_configs()` and `is_ttl_configs_frozen()` callable without auth.
-// - `set_ttl_configs` requires owner authorization.
-// - Invalid TTL config (threshold > extend_to) is rejected.
-
-use common_macros::{ownable, ttl_configurable};
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    xdr::{ScErrorCode, ScErrorType},
-    Address, Env, Error, IntoVal,
-};
-use utils::testing_utils::assert_eq_event;
-use utils::ttl_configurable::TtlConfigsSet;
-use utils::{errors::{AuthError, TtlConfigurableError}, ttl_configurable::TtlConfig};
-
-#[contract]
-#[ttl_configurable]
-#[ownable]
-pub struct TestContract;
-
-#[contractimpl]
-impl TestContract {
-    pub fn init(env: Env, owner: Address) {
-        Self::init_owner(&env, &owner);
-    }
-}
-
-#[test]
-fn read_without_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Read methods should be callable without initialization/auth
-    assert_eq!(client.ttl_configs(), (None, None));
-    assert!(!client.is_ttl_configs_frozen());
-
-    // Also works after owner initialization
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    assert_eq!(client.ttl_configs(), (None, None));
-    assert!(!client.is_ttl_configs_frozen());
-}
-
-#[test]
-fn set_requires_auth() {
-    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 before = client.ttl_configs();
-
-    let instance = Some(TtlConfig::new(1, 2));
-    let persistent = None::<TtlConfig>;
-
-    // Unauthorized set should fail
-    let unauthorized = client.try_set_ttl_configs(&instance, &persistent);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized set should succeed
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_ttl_configs",
-                args: (&instance, &persistent).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .set_ttl_configs(&instance, &persistent);
-
-    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
-
-    // Config should be updated
-    let after = client.ttl_configs();
-    assert_ne!(before, after);
-    assert_eq!(after, (instance, persistent));
-}
-
-#[test]
-fn set_before_init_fails_with_owner_not_set() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // No init() call => Ownable owner not set, so Auth::authorizer() fails.
-    let instance = Some(TtlConfig::new(1, 2));
-    let persistent = None::<TtlConfig>;
-    let err = client.try_set_ttl_configs(&instance, &persistent).unwrap_err().unwrap();
-    assert_eq!(err, AuthError::AuthorizerNotFound.into());
-}
-
-#[test]
-fn set_and_remove_configs_roundtrip() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    // Set both configs.
-    let instance = Some(TtlConfig::new(1, 2));
-    let persistent = Some(TtlConfig::new(3, 4));
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_ttl_configs",
-                args: (&instance, &persistent).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .set_ttl_configs(&instance, &persistent);
-
-    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance, persistent });
-    assert_eq!(client.ttl_configs(), (instance, persistent));
-
-    // Remove (disable) both configs.
-    let none: Option<TtlConfig> = None::<TtlConfig>;
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_ttl_configs",
-                args: (&none, &none).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .set_ttl_configs(&none, &none);
-
-    assert_eq_event(&env, &contract_id, TtlConfigsSet { instance: none, persistent: none });
-    assert_eq!(client.ttl_configs(), (None, None));
-}
-
-#[test]
-fn invalid_config_rejected() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    let before = client.ttl_configs();
-
-    // Invalid config: threshold > extend_to
-    let invalid_instance = Some(TtlConfig::new(100, 50)); // threshold=100 > extend_to=50
-    let none: Option<TtlConfig> = None::<TtlConfig>;
-
-    let result = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_ttl_configs",
-                args: (&invalid_instance, &none).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_set_ttl_configs(&invalid_instance, &none);
-
-    assert_eq!(result.unwrap_err().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
-    // Config should remain unchanged on validation failure.
-    assert_eq!(client.ttl_configs(), before);
-}
-
-#[test]
-fn invalid_max_ttl_rejected() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner);
-
-    let invalid = Some(TtlConfig::new(1, u32::MAX));
-    let none: Option<TtlConfig> = None::<TtlConfig>;
-
-    let result = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_ttl_configs",
-                args: (&invalid, &none).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_set_ttl_configs(&invalid, &none);
-
-    assert_eq!(result.unwrap_err().unwrap(), TtlConfigurableError::InvalidTtlConfig.into());
-}

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

@@ -1,143 +0,0 @@
-// Runtime tests: TTL config freeze behavior.
-//
-// Tests covered:
-// - `freeze_ttl_configs` requires owner authorization.
-// - After freeze, `set_ttl_configs` fails even with auth.
-// - Double freeze fails with TtlConfigAlreadyFrozen.
-
-use common_macros::{ownable, ttl_configurable};
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    xdr::{ScErrorCode, ScErrorType},
-    Address, Env, Error, IntoVal,
-};
-use utils::testing_utils::assert_eq_event;
-use utils::ttl_configurable::TtlConfigsFrozen;
-use utils::{errors::TtlConfigurableError, ttl_configurable::TtlConfig};
-
-#[contract]
-#[ttl_configurable]
-#[ownable]
-pub struct TestContract;
-
-#[contractimpl]
-impl TestContract {
-    pub fn init(env: Env, owner: Address) {
-        Self::init_owner(&env, &owner);
-    }
-}
-
-#[test]
-fn freeze_requires_auth() {
-    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);
-
-    // Unauthorized freeze should fail
-    assert_eq!(
-        client.try_freeze_ttl_configs().unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized freeze should succeed
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "freeze_ttl_configs",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .freeze_ttl_configs();
-
-    assert_eq_event(&env, &contract_id, TtlConfigsFrozen {});
-
-    assert!(client.is_ttl_configs_frozen());
-}
-
-#[test]
-fn freeze_blocks_set() {
-    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);
-
-    // Freeze the config
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "freeze_ttl_configs",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .freeze_ttl_configs();
-
-    // After freeze, set should fail even with auth
-    let instance = Some(TtlConfig::new(1, 2));
-    let none = None::<TtlConfig>;
-
-    let result = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_ttl_configs",
-                args: (&instance, &none).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_set_ttl_configs(&instance, &none);
-
-    assert_eq!(result.unwrap_err().unwrap(), TtlConfigurableError::TtlConfigFrozen.into());
-}
-
-#[test]
-fn double_freeze_fails() {
-    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);
-
-    // First freeze should succeed
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "freeze_ttl_configs",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .freeze_ttl_configs();
-
-    assert!(client.is_ttl_configs_frozen());
-
-    // Second freeze should fail (TtlConfigAlreadyFrozen)
-    let result = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "freeze_ttl_configs",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_freeze_ttl_configs();
-
-    assert_eq!(result.unwrap_err().unwrap(), TtlConfigurableError::TtlConfigAlreadyFrozen.into());
-}

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

@@ -1,2 +0,0 @@
-mod configuration;
-mod freeze;

package/contracts/macro-integration-tests/tests/runtime/ttl_extendable/extend_instance_ttl.rs

@@ -1,64 +0,0 @@
-// Runtime tests: `#[ttl_extendable]` behavior (manual instance TTL extension).
-
-use super::{TestContract, TestContractClient};
-use soroban_sdk::testutils::{storage::Instance as _, Ledger as _};
-use soroban_sdk::Env;
-use utils::ttl_configurable::{TtlConfig, TtlConfigStorage};
-
-#[test]
-fn extend_instance_ttl_extends_instance_storage() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Ensure instance storage exists.
-    client.touch();
-
-    let before = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    let before_seq = env.ledger().sequence();
-    let live_until = before_seq + before;
-
-    // Move ledger forward so current TTL equals a small number, then extend.
-    let threshold = 1u32;
-    env.ledger().set_sequence_number(live_until.saturating_sub(threshold));
-    let extend_to = threshold + 50;
-
-    client.extend_instance_ttl(&threshold, &extend_to);
-
-    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    assert_eq!(after, extend_to);
-}
-
-#[test]
-fn extend_instance_ttl_does_not_auto_extend_from_config() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Ensure instance storage exists so TTL is meaningful.
-    client.touch();
-
-    // Capture current TTL and compute live_until.
-    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 an instance TTL auto-extension config that would trigger at threshold=10 and extend to before+100.
-    // NOTE: `#[ttl_extendable]` intentionally uses `#[soroban_sdk::contractimpl]` (not `common_macros::contract_impl`),
-    // so calling `extend_instance_ttl` should NOT also run any auto-TTL extension logic.
-    let cfg = TtlConfig::new(10, before + 100);
-    env.as_contract(&contract_id, || {
-        TtlConfigStorage::set_instance(&env, &cfg);
-    });
-
-    // Move ledger so current TTL equals cfg.threshold (this is the would-be auto-extension trigger point).
-    env.ledger().set_sequence_number(live_until.saturating_sub(cfg.threshold));
-
-    // Call manual extension with a threshold that should NOT trigger (0), regardless of extend_to.
-    client.extend_instance_ttl(&0, &9999);
-
-    // If auto-extension were incorrectly injected, TTL would become cfg.extend_to.
-    // Instead, it should remain at the current TTL (cfg.threshold).
-    let after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
-    assert_eq!(after, cfg.threshold);
-}

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

@@ -1,16 +0,0 @@
-use soroban_sdk::{contract, Env};
-
-mod extend_instance_ttl;
-
-/// Shared contract used by ttl_extendable runtime tests.
-#[contract]
-#[common_macros::ttl_extendable]
-pub struct TestContract;
-
-#[soroban_sdk::contractimpl]
-impl TestContract {
-    pub fn touch(env: Env) {
-        // Create some instance storage state so instance TTL is meaningful.
-        env.storage().instance().set(&soroban_sdk::Symbol::new(&env, "touched"), &true);
-    }
-}