@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/utils/src/ownable.rs

@@ -0,0 +1,88 @@
+use crate as utils;
+use crate::option_ext::OptionExt;
+use crate::{errors::OwnableError, ttl::DefaultTtlConfigProvider};
+use common_macros::{event, storage};
+use soroban_sdk::{assert_with_error, contractclient, Address, Env};
+
+// ============================================
+// Ownable Interface
+// ============================================
+
+/// Trait for contracts with single-owner access control.
+#[contractclient(name = "OwnableClient")]
+pub trait Ownable {
+    /// Returns the current owner address, or None if no owner is set.
+    fn owner(env: &Env) -> Option<Address>;
+
+    /// Transfers ownership to a new address. Requires current owner authorization.
+    fn transfer_ownership(env: &Env, new_owner: &Address);
+
+    /// Permanently renounces ownership. Requires current owner authorization.
+    fn renounce_ownership(env: &Env);
+}
+
+/// Enforces owner authorization and returns the owner address.
+/// Panics if no owner is set or authorization fails.
+pub fn enforce_owner_auth<T: Ownable>(env: &Env) -> Address {
+    let owner = T::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet);
+    owner.require_auth();
+    owner
+}
+
+/// Enforces owner authorization without returning the address.
+pub fn require_owner_auth<T: Ownable>(env: &Env) {
+    let _ = enforce_owner_auth::<T>(env);
+}
+
+/// Event emitted when ownership is transferred.
+#[event]
+pub struct OwnershipTransferred {
+    pub old_owner: Address,
+    pub new_owner: Address,
+}
+
+/// Event emitted when ownership is renounced.
+#[event]
+pub struct OwnershipRenounced {
+    pub old_owner: Address,
+}
+
+// ============================================
+// Default Ownable Implementation
+// ============================================
+
+/// Default implementation of the Ownable trait using instance storage.
+pub struct DefaultOwnable;
+
+/// Storage keys for DefaultOwnable.
+#[storage(DefaultTtlConfigProvider)]
+pub enum DefaultOwnableStorage {
+    #[instance(Address)]
+    Owner,
+}
+
+impl Ownable for DefaultOwnable {
+    fn owner(env: &Env) -> Option<Address> {
+        DefaultOwnableStorage::owner(env)
+    }
+
+    fn transfer_ownership(env: &Env, new_owner: &Address) {
+        let old_owner = enforce_owner_auth::<Self>(env);
+        DefaultOwnableStorage::set_owner(env, new_owner);
+        OwnershipTransferred { old_owner, new_owner: new_owner.clone() }.publish(env);
+    }
+
+    fn renounce_ownership(env: &Env) {
+        let old_owner = enforce_owner_auth::<Self>(env);
+        DefaultOwnableStorage::remove_owner(env);
+        OwnershipRenounced { old_owner }.publish(env);
+    }
+}
+
+impl DefaultOwnable {
+    /// Initializes the owner. This should only be called once at contract initialization.
+    pub fn init_owner(env: &Env, owner: &Address) {
+        assert_with_error!(env, !DefaultOwnableStorage::has_owner(env), OwnableError::OwnerAlreadySet);
+        DefaultOwnableStorage::set_owner(env, owner);
+    }
+}

package/contracts/utils/src/testing_utils.rs

@@ -0,0 +1,100 @@
+use soroban_sdk::{testutils::Events, xdr::ToXdr, Address, Env, Event, Val, Vec};
+
+fn topics_eq(env: &Env, a: &Vec<Val>, b: &Vec<Val>) -> bool {
+    if a.len() != b.len() {
+        return false;
+    }
+    for i in 0..a.len() {
+        let av = a.get(i).unwrap();
+        let bv = b.get(i).unwrap();
+        // Compare XDR serialization for deep value equality
+        if av.to_xdr(env) != bv.to_xdr(env) {
+            return false;
+        }
+    }
+    true
+}
+
+fn data_eq(env: &Env, a: &Val, b: &Val) -> bool {
+    // Compare XDR serialization for deep value equality
+    a.to_xdr(env) == b.to_xdr(env)
+}
+
+/// Asserts that an event matching the expected event was emitted from the contract.
+///
+/// Uses the event struct's `.topics()` and `.data()` methods (generated by `#[contractevent]`)
+/// to compare against emitted events. No more hardcoding topic names or field keys!
+///
+/// # Example
+/// ```ignore
+/// use crate::events::OwnershipTransferred;
+///
+/// let expected = OwnershipTransferred {
+///     previous_owner: owner.clone(),
+///     new_owner: new_owner.clone(),
+/// };
+/// assert_event(&env, &contract, expected);
+/// ```
+pub fn assert_event<E: Event>(env: &Env, contract: &Address, expected: E) {
+    let events = env.events().all();
+    let expected_topics: Vec<Val> = expected.topics(env);
+    let expected_data: Val = expected.data(env);
+
+    let mut found = false;
+    for (address, topics, data) in events.iter() {
+        if &address == contract && topics_eq(env, &topics, &expected_topics) && data_eq(env, &data, &expected_data) {
+            found = true;
+            break;
+        }
+    }
+
+    assert!(found, "Expected event not found. Expected topics: {:?}, data: {:?}", expected_topics, expected_data);
+}
+
+/// A helper struct to hold event topics and data for batch assertion with mixed event types.
+pub struct ExpectedEvent {
+    pub topics: Vec<Val>,
+    pub data: Val,
+}
+
+pub trait IntoExpectedEvent: Event + Sized {
+    fn expected(self, env: &Env) -> ExpectedEvent {
+        ExpectedEvent { topics: self.topics(env), data: self.data(env) }
+    }
+}
+
+// Blanket implementation for all Event types
+impl<E: Event> IntoExpectedEvent for E {}
+
+/// Asserts that all expected events were emitted from the contract (in any order).
+/// Use this when asserting multiple events of different types.
+///
+/// # Example
+/// ```ignore
+/// use utils::testing_utils::IntoExpectedEvent;
+///
+/// assert_events(env, &contract, &[
+///     Event1 { ... }.expected(env),
+///     Event2 { ... }.expected(env),
+/// ]);
+/// ```
+pub fn assert_events(env: &Env, contract: &Address, expected_events: &[ExpectedEvent]) {
+    let events = env.events().all();
+
+    for (i, expected) in expected_events.iter().enumerate() {
+        let mut found = false;
+        for (address, topics, data) in events.iter() {
+            if &address == contract && topics_eq(env, &topics, &expected.topics) && data_eq(env, &data, &expected.data)
+            {
+                found = true;
+                break;
+            }
+        }
+
+        assert!(
+            found,
+            "Expected event #{} not found. Expected topics: {:?}, data: {:?}",
+            i, expected.topics, expected.data
+        );
+    }
+}