@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

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

@@ -0,0 +1,137 @@
+// 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);
+
+            // 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

@@ -0,0 +1,113 @@
+// 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::errors::TtlConfigurableError;
+
+#[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
+    client.ttl_configs();
+    assert!(!client.is_ttl_configs_frozen());
+
+    // Also works after owner initialization
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    client.ttl_configs();
+    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);
+
+    // Config should be updated
+    let after = client.ttl_configs();
+    assert_ne!(before, after);
+    assert_eq!(after, (instance, persistent));
+}
+
+#[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);
+
+    // 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());
+}

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

@@ -0,0 +1,50 @@
+// Runtime tests: `extend_instance_ttl` behavior.
+//
+// Tests covered:
+// - `extend_instance_ttl` exists on `#[ttl_configurable]` contracts and manually extends instance TTL.
+
+use common_macros::{ownable, ttl_configurable};
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{storage::Instance as _, Address as _, Ledger as _},
+    Address, Env,
+};
+
+#[contract]
+#[ttl_configurable]
+#[ownable]
+pub struct TestContract;
+
+#[contractimpl]
+impl TestContract {
+    pub fn init(env: Env, owner: Address) {
+        Self::init_owner(&env, &owner);
+    }
+}
+
+#[test]
+fn extend_instance_ttl_extends() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // Write something to ensure instance storage exists and has a TTL.
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    let (ttl_before, seq_before) =
+        env.as_contract(&contract_id, || (env.storage().instance().get_ttl(), env.ledger().sequence()));
+    let live_until = seq_before + ttl_before;
+
+    // Choose a threshold near the current TTL and extend further.
+    let threshold = ttl_before.saturating_sub(1);
+    let extend_to = ttl_before + 50;
+
+    // Set sequence so remaining TTL == threshold (i.e. at the trigger point).
+    env.ledger().set_sequence_number(live_until - threshold);
+
+    client.extend_instance_ttl(&threshold, &extend_to);
+
+    let ttl_after = env.as_contract(&contract_id, || env.storage().instance().get_ttl());
+    assert_eq!(ttl_after, extend_to);
+}

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

@@ -0,0 +1,139 @@
+// 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::errors::TtlConfigurableError;
+
+#[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!(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

@@ -0,0 +1,3 @@
+mod configuration;
+mod extend_instance_ttl;
+mod freeze;

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

@@ -0,0 +1,5 @@
+mod runtime {
+    mod ownable;
+    mod storage;
+    mod ttl_configurable;
+}

package/contracts/macro-integration-tests/tests/ui/error/fail/attr_not_empty.rs

@@ -0,0 +1,12 @@
+// UI (trybuild) negative test: `#[contract_error]` does not accept arguments.
+//
+// Purpose:
+// - Ensures passing arguments to the attribute causes a compile-time failure.
+// - The macro asserts the attribute token stream is empty.
+
+#[common_macros::contract_error(foo)]
+pub enum MyError {
+    A,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/error/fail/attr_not_empty.stderr

@@ -0,0 +1,7 @@
+error: custom attribute panicked
+ --> tests/ui/error/fail/attr_not_empty.rs:7:1
+  |
+7 | #[common_macros::contract_error(foo)]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: contract_error attribute is not supported

package/contracts/macro-integration-tests/tests/ui/error/fail/decreasing_discriminant.rs

@@ -0,0 +1,12 @@
+// UI (trybuild) negative test: discriminant values must be monotonically increasing.
+//
+// Purpose:
+// - Ensures the macro rejects explicit discriminants that decrease relative to the previous value.
+
+#[common_macros::contract_error]
+pub enum MyError {
+    A = 10,
+    B = 9,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/error/fail/decreasing_discriminant.stderr

@@ -0,0 +1,7 @@
+error: custom attribute panicked
+ --> tests/ui/error/fail/decreasing_discriminant.rs:6:1
+  |
+6 | #[common_macros::contract_error]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: Error enum discriminant must be greater than the previous discriminant

package/contracts/macro-integration-tests/tests/ui/error/fail/non_int_discriminant.rs

@@ -0,0 +1,21 @@
+// UI (trybuild) negative test: only integer discriminants are supported.
+//
+// Purpose:
+// - Ensures non-integer discriminants (string literal, expression, const path) are rejected.
+// - The macro expects a literal integer discriminant.
+
+const X: u32 = 7;
+
+#[common_macros::contract_error]
+pub enum MyError {
+    // Not an integer literal (string)
+    A = "1",
+
+    // Not a literal int expression (path)
+    B = X,
+
+    // Not a literal int expression (binary expression)
+    C = 1 + 2,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/error/fail/non_int_discriminant.stderr

@@ -0,0 +1,7 @@
+error: custom attribute panicked
+ --> tests/ui/error/fail/non_int_discriminant.rs:9:1
+  |
+9 | #[common_macros::contract_error]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: Error enum discriminant must be an integer literal

package/contracts/macro-integration-tests/tests/ui/error/fail/non_unit_variant.rs

@@ -0,0 +1,13 @@
+// UI (trybuild) negative test: non-unit variants are rejected.
+//
+// Purpose:
+// - Ensures tuple variants and struct variants cause a compile-time failure.
+// - The macro only supports unit variants.
+
+#[common_macros::contract_error]
+pub enum MyError {
+    Tuple(u32),
+    Struct { x: u32 },
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/error/fail/non_unit_variant.stderr

@@ -0,0 +1,7 @@
+error: custom attribute panicked
+ --> tests/ui/error/fail/non_unit_variant.rs:7:1
+  |
+7 | #[common_macros::contract_error]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = help: message: Error enum variants must be unit variants

package/contracts/macro-integration-tests/tests/ui/error/pass/attr_on_variant_allowed.rs

@@ -0,0 +1,20 @@
+// UI (trybuild) test: variant attributes are preserved/allowed.
+//
+// Purpose:
+// - Ensures attributes on variants (e.g., doc strings) do not break macro processing.
+// - The macro implementation forwards variant attributes; this test catches regressions.
+// - Avoids attributes that may introduce warnings (e.g., `#[deprecated]`) to keep CI output clean.
+
+#[common_macros::contract_error]
+pub enum MyError {
+    #[doc = "A documented error variant."]
+    A,
+
+    #[doc = "Another documented error variant (used to ensure multiple attrs are handled)."]
+    B,
+
+    #[doc = "A third documented error variant."]
+    C,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/error/pass/basic_auto_discriminants.rs

@@ -0,0 +1,15 @@
+// UI (trybuild) test: `#[contract_error]` on a unit-only enum without explicit discriminants compiles.
+//
+// Purpose:
+// - Covers the happy path where all variants are unit variants.
+// - Ensures the macro auto-assigns monotonically increasing integer discriminants starting at 1.
+// - Avoids snapshotting token output; compilation success is sufficient for this integration contract.
+
+#[common_macros::contract_error]
+pub enum MyError {
+    A,
+    B,
+    C,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/error/pass/mixed_discriminants.rs

@@ -0,0 +1,16 @@
+// UI (trybuild) test: `#[contract_error]` supports a mix of explicit and implicit discriminants.
+//
+// Purpose:
+// - Ensures explicit integer discriminants are accepted.
+// - Ensures subsequent variants without discriminants are auto-assigned based on the last explicit value.
+// - Example shape: A=10, B(implicit), C=20, D(implicit).
+
+#[common_macros::contract_error]
+pub enum MyError {
+    A = 10,
+    B,
+    C = 20,
+    D,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/ownable/fail/only_owner_missing_env.rs

@@ -0,0 +1,22 @@
+// UI (trybuild) negative test: `#[only_owner]` requires an `Env` parameter.
+//
+// Purpose:
+// - Ensures the macro fails compilation when applied to a function that does not accept `Env`.
+// - Validates the downstream UX: macro misuse should surface as a compile-time error.
+
+use soroban_sdk::{contract, contractimpl};
+
+#[contract]
+#[common_macros::ownable]
+pub struct MyContract;
+
+#[contractimpl]
+impl MyContract {
+    // Intentionally missing `Env`: should fail during macro expansion.
+    #[common_macros::only_owner]
+    pub fn bad(x: u32) {
+        let _ = x;
+    }
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/ownable/fail/only_owner_missing_env.stderr

@@ -0,0 +1,16 @@
+error: custom attribute panicked
+  --> tests/ui/ownable/fail/only_owner_missing_env.rs:16:5
+   |
+16 |     #[common_macros::only_owner]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: message: function must have an Env argument
+
+error[E0599]: no function or associated item named `bad` found for struct `MyContract` in the current scope
+  --> tests/ui/ownable/fail/only_owner_missing_env.rs:17:12
+   |
+11 | pub struct MyContract;
+   | --------------------- function or associated item `bad` not found for this struct
+...
+17 |     pub fn bad(x: u32) {
+   |            ^^^ function or associated item not found in `MyContract`

package/contracts/macro-integration-tests/tests/ui/ownable/pass/minimal_contract.rs

@@ -0,0 +1,26 @@
+// UI (trybuild) test: minimal ownable usage compiles.
+//
+// Purpose:
+// - Verifies `#[common_macros::ownable]` can be applied on a contract struct.
+// - Verifies macro-generated items exist and are type-checkable from downstream code:
+//   - `Self::init_owner(&Env, &Address)` helper
+//   - `utils::ownable::Ownable` trait impl for the contract
+
+use soroban_sdk::{contract, contractimpl, Address, Env};
+
+#[contract]
+#[common_macros::ownable]
+pub struct MyContract;
+
+#[contractimpl]
+impl MyContract {
+    pub fn init(env: Env, owner: Address) {
+        // `init_owner` is generated by `#[ownable]` as a helper on the contract type.
+        Self::init_owner(&env, &owner);
+
+        // Ensure the trait impl exists (type-check only).
+        let _ = <Self as utils::ownable::Ownable>::owner(&env);
+    }
+}
+
+fn main() {}