feat(creator-earnings): emit events for primary state changes

Add InitializedEvent, AuthorizedAddedEvent, and DepositEvent structs.
Emit events at the end of initialize(), add_authorized(), and deposit()
alongside the existing WithdrawEvent in withdraw().
Add tests verifying each new event is emitted with correct data.

Closes #942

Author: Xaxxoo

contract/contracts/creator-earnings/src/lib.rs

@@ -40,7 +40,30 @@ pub enum Error {
     InvalidAmount = 5,
 }
 
-/// -------- Events (INLINE) --------
+/// -------- Events --------
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct InitializedEvent {
+    pub admin: Address,
+    pub token: Address,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AuthorizedAddedEvent {
+    pub depositor: Address,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DepositEvent {
+    pub from: Address,
+    pub creator: Address,
+    pub amount: i128,
+    pub token: Address,
+}
+
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct WithdrawEvent {
@@ -50,6 +73,9 @@ pub struct WithdrawEvent {
 }
 
 /// Avoid magic strings
+const INITIALIZED_EVENT: &str = "initialized";
+const AUTHORIZED_ADDED_EVENT: &str = "authorized_added";
+const DEPOSIT_EVENT: &str = "deposit";
 const WITHDRAW_EVENT: &str = "withdraw";
 
 #[contract]
@@ -69,6 +95,14 @@ impl CreatorEarnings {
         env.storage()
             .instance()
             .set(&DataKey::Token, &token_address);
+
+        env.events().publish(
+            (Symbol::new(&env, INITIALIZED_EVENT),),
+            InitializedEvent {
+                admin,
+                token: token_address,
+            },
+        );
     }
 
     /// Add authorized depositor contract (admin only)
@@ -78,7 +112,12 @@ impl CreatorEarnings {
 
         env.storage()
             .instance()
-            .set(&DataKey::AuthorizedDepositor(contract), &true);
+            .set(&DataKey::AuthorizedDepositor(contract.clone()), &true);
+
+        env.events().publish(
+            (Symbol::new(&env, AUTHORIZED_ADDED_EVENT),),
+            AuthorizedAddedEvent { depositor: contract },
+        );
     }
 
     /// Deposit earnings for creator
@@ -102,6 +141,16 @@ impl CreatorEarnings {
         env.storage()
             .instance()
             .set(&DataKey::Balance(creator.clone()), &new_balance);
+
+        env.events().publish(
+            (Symbol::new(&env, DEPOSIT_EVENT),),
+            DepositEvent {
+                from,
+                creator,
+                amount,
+                token: token_address,
+            },
+        );
     }
 
     /// Get creator balance
@@ -112,7 +161,7 @@ impl CreatorEarnings {
             .unwrap_or(0)
     }
 
-    /// Withdraw earnings (WITH EVENT)
+    /// Withdraw earnings
     pub fn withdraw(env: Env, creator: Address, amount: i128) {
         if amount <= 0 {
             panic_with_error!(&env, Error::InvalidAmount);
@@ -141,7 +190,6 @@ impl CreatorEarnings {
             .instance()
             .set(&DataKey::Balance(creator.clone()), &new_balance);
 
-        // ✅ Typed event emission
         env.events().publish(
             (Symbol::new(&env, WITHDRAW_EVENT),),
             WithdrawEvent {

contract/contracts/creator-earnings/src/test.rs

@@ -240,3 +240,129 @@ fn withdraw_failed_emits_no_event() {
     assert_eq!(client.balance(&creator), 500);
     assert!(env.events().all().len() >= events_before);
 }
+
+// -------- Event tests for issue #942: emit events for primary state changes --------
+
+#[test]
+fn initialize_emits_event() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let token_admin = Address::generate(&env);
+    #[allow(deprecated)]
+    let token_id = env.register_stellar_asset_contract(token_admin.clone());
+
+    let contract_id = env.register_contract(None, CreatorEarnings);
+    let client = CreatorEarningsClient::new(&env, &contract_id);
+
+    client.initialize(&admin, &token_id);
+
+    let all_events = env.events().all();
+    let mut init_event: Option<(
+        Address,
+        soroban_sdk::Vec<soroban_sdk::Val>,
+        soroban_sdk::Val,
+    )> = None;
+    for i in 0..all_events.len() {
+        let evt = all_events.get(i).unwrap();
+        let (id, topics, _) = &evt;
+        if *id != client.address {
+            continue;
+        }
+        let t0: Option<Symbol> = topics.get(0).and_then(|v| v.try_into_val(&env).ok());
+        if t0 == Some(Symbol::new(&env, "initialized")) {
+            init_event = Some(evt);
+            break;
+        }
+    }
+
+    let event = init_event.expect("initialized event not emitted");
+    let data: InitializedEvent = event.2.try_into_val(&env).unwrap();
+    assert_eq!(data.admin, admin);
+    assert_eq!(data.token, token_id);
+}
+
+#[test]
+fn add_authorized_emits_event() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let token_admin = Address::generate(&env);
+    #[allow(deprecated)]
+    let token_id = env.register_stellar_asset_contract(token_admin.clone());
+
+    let contract_id = env.register_contract(None, CreatorEarnings);
+    let client = CreatorEarningsClient::new(&env, &contract_id);
+
+    client.initialize(&admin, &token_id);
+
+    let depositor = Address::generate(&env);
+    client.add_authorized(&depositor);
+
+    let all_events = env.events().all();
+    let mut auth_event: Option<(
+        Address,
+        soroban_sdk::Vec<soroban_sdk::Val>,
+        soroban_sdk::Val,
+    )> = None;
+    for i in 0..all_events.len() {
+        let evt = all_events.get(i).unwrap();
+        let (id, topics, _) = &evt;
+        if *id != client.address {
+            continue;
+        }
+        let t0: Option<Symbol> = topics.get(0).and_then(|v| v.try_into_val(&env).ok());
+        if t0 == Some(Symbol::new(&env, "authorized_added")) {
+            auth_event = Some(evt);
+            break;
+        }
+    }
+
+    let event = auth_event.expect("authorized_added event not emitted");
+    let data: AuthorizedAddedEvent = event.2.try_into_val(&env).unwrap();
+    assert_eq!(data.depositor, depositor);
+}
+
+#[test]
+fn deposit_emits_event() {
+    let env = Env::default();
+
+    let (_admin, creator, depositor, client, _, _) = setup(&env);
+
+    let token_address: Address = env.as_contract(&client.address, || {
+        env.storage()
+            .instance()
+            .get(&DataKey::Token)
+            .expect("token not set")
+    });
+
+    client.deposit(&depositor, &creator, &300);
+
+    let all_events = env.events().all();
+    let mut dep_event: Option<(
+        Address,
+        soroban_sdk::Vec<soroban_sdk::Val>,
+        soroban_sdk::Val,
+    )> = None;
+    for i in 0..all_events.len() {
+        let evt = all_events.get(i).unwrap();
+        let (id, topics, _) = &evt;
+        if *id != client.address {
+            continue;
+        }
+        let t0: Option<Symbol> = topics.get(0).and_then(|v| v.try_into_val(&env).ok());
+        if t0 == Some(Symbol::new(&env, "deposit")) {
+            dep_event = Some(evt);
+            break;
+        }
+    }
+
+    let event = dep_event.expect("deposit event not emitted");
+    let data: DepositEvent = event.2.try_into_val(&env).unwrap();
+    assert_eq!(data.from, depositor);
+    assert_eq!(data.creator, creator);
+    assert_eq!(data.amount, 300);
+    assert_eq!(data.token, token_address);
+}