feat(v1): emit RotationVoted event on intermediate votes (#130)

contracts/tholos/src/lib.rs

@@ -69,6 +69,16 @@ pub struct RotationCancelled {
     pub new_resolver: Address,
 }
 
+#[contractevent]
+pub struct RotationVoted {
+    pub old_resolver: Address,
+    pub new_resolver: Address,
+    pub resolver: Address,
+    pub approve: bool,
+    pub yes_votes: u32,
+    pub no_votes: u32,
+}
+
 /// An in-flight single-slot committee rotation proposed by a current resolver.
 /// Decided by a strict majority of the live committee via `vote_rotation`. Only
 /// one may be open at a time. See `docs/src/ROTATION_DESIGN.md`.
@@ -423,7 +433,8 @@ impl Tholos {
         // test_rotation_vote_twice_fails (AlreadyVoted),
         // test_non_resolver_cannot_vote_rotation (NotAResolver),
         // test_deadlock_autocancels_rotation (deadlock guard),
-        // test_cannot_vote_rotation_without_proposal (NoRotationProposal below).
+        // test_cannot_vote_rotation_without_proposal (NoRotationProposal below),
+        // test_rotation_vote_emits_event (RotationVoted event).
         let mut proposal: RotationProposal = env
             .storage()
             .instance()
@@ -442,9 +453,9 @@ impl Tholos {
         }
 
         if approve {
-            proposal.yes.push_back(resolver);
+            proposal.yes.push_back(resolver.clone());
         } else {
-            proposal.no.push_back(resolver);
+            proposal.no.push_back(resolver.clone());
         }
 
         let n = committee.len();
@@ -497,6 +508,15 @@ impl Tholos {
         env.storage()
             .instance()
             .set(&DataKey::RotationProposal, &proposal);
+        RotationVoted {
+            old_resolver: proposal.old_resolver.clone(),
+            new_resolver: proposal.new_resolver.clone(),
+            resolver,
+            approve,
+            yes_votes: proposal.yes.len(),
+            no_votes: proposal.no.len(),
+        }
+        .publish(&env);
         Ok(None)
     }
 

contracts/tholos/src/test.rs

@@ -2,7 +2,8 @@
 
 use super::*;
 use soroban_sdk::testutils::storage::{Instance as _, Persistent as _};
-use soroban_sdk::testutils::{Address as _, Ledger};
+use soroban_sdk::testutils::{Address as _, Events as _, Ledger};
+use soroban_sdk::{xdr, IntoVal, Symbol, TryFromVal, Val};
 
 const DEFAULT_BOND: i128 = 100;
 const DEFAULT_WINDOW: u64 = 3600;
@@ -1225,6 +1226,201 @@ fn test_rotation_requires_majority_then_executes() {
     assert_eq!(f.token.balance(&disputer), 1_100);
 }
 
+#[test]
+fn test_rotation_vote_emits_event() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let token_admin = Address::generate(&env);
+    let token_id = env
+        .register_stellar_asset_contract_v2(token_admin)
+        .address();
+    let resolvers = Vec::from_array(
+        &env,
+        [
+            Address::generate(&env),
+            Address::generate(&env),
+            Address::generate(&env),
+            Address::generate(&env),
+            Address::generate(&env),
+        ],
+    );
+
+    let contract_id = env.register(Tholos, ());
+    let client = TholosClient::new(&env, &contract_id);
+    client.initialize(
+        &admin,
+        &token_id,
+        &DEFAULT_BOND,
+        &DEFAULT_WINDOW,
+        &resolvers,
+        &0,
+    );
+
+    let old_resolver = resolvers.get(0).unwrap();
+    let new_resolver = Address::generate(&env);
+
+    client.propose_rotation(&old_resolver, &old_resolver, &new_resolver);
+
+    // Vote 1: No-vote (approve = false) from resolver 1. Intermediate vote -> Ok(None).
+    let r1 = resolvers.get(1).unwrap();
+    let res1 = client.try_vote_rotation(&r1, &false);
+    assert_eq!(res1, Ok(Ok(None)));
+
+    let events = env.events().all().filter_by_contract(&contract_id);
+    let last_event = events.events().last().unwrap().clone();
+    let (topics, data) = match &last_event.body {
+        xdr::ContractEventBody::V0(body) => (&body.topics, &body.data),
+    };
+    let topic0 = Symbol::try_from_val(&env, topics.first().unwrap()).unwrap();
+    assert_eq!(topic0, Symbol::new(&env, "rotation_voted"));
+    let data_val = Val::try_from_val(&env, data).unwrap();
+    let map: soroban_sdk::Map<Symbol, Val> = data_val.into_val(&env);
+    let old_r: Address = map
+        .get(Symbol::new(&env, "old_resolver"))
+        .unwrap()
+        .into_val(&env);
+    let new_r: Address = map
+        .get(Symbol::new(&env, "new_resolver"))
+        .unwrap()
+        .into_val(&env);
+    let voter: Address = map
+        .get(Symbol::new(&env, "resolver"))
+        .unwrap()
+        .into_val(&env);
+    let app: bool = map
+        .get(Symbol::new(&env, "approve"))
+        .unwrap()
+        .into_val(&env);
+    let yes: u32 = map
+        .get(Symbol::new(&env, "yes_votes"))
+        .unwrap()
+        .into_val(&env);
+    let no: u32 = map
+        .get(Symbol::new(&env, "no_votes"))
+        .unwrap()
+        .into_val(&env);
+    assert_eq!(old_r, old_resolver);
+    assert_eq!(new_r, new_resolver);
+    assert_eq!(voter, r1);
+    assert!(!app);
+    assert_eq!(yes, 0);
+    assert_eq!(no, 1);
+
+    // Vote 2: Yes-vote (approve = true) from resolver 2. Intermediate vote -> Ok(None).
+    let r2 = resolvers.get(2).unwrap();
+    let res2 = client.try_vote_rotation(&r2, &true);
+    assert_eq!(res2, Ok(Ok(None)));
+
+    let events = env.events().all().filter_by_contract(&contract_id);
+    let last_event = events.events().last().unwrap().clone();
+    let (topics, data) = match &last_event.body {
+        xdr::ContractEventBody::V0(body) => (&body.topics, &body.data),
+    };
+    let topic0 = Symbol::try_from_val(&env, topics.first().unwrap()).unwrap();
+    assert_eq!(topic0, Symbol::new(&env, "rotation_voted"));
+    let data_val = Val::try_from_val(&env, data).unwrap();
+    let map: soroban_sdk::Map<Symbol, Val> = data_val.into_val(&env);
+    let old_r: Address = map
+        .get(Symbol::new(&env, "old_resolver"))
+        .unwrap()
+        .into_val(&env);
+    let new_r: Address = map
+        .get(Symbol::new(&env, "new_resolver"))
+        .unwrap()
+        .into_val(&env);
+    let voter: Address = map
+        .get(Symbol::new(&env, "resolver"))
+        .unwrap()
+        .into_val(&env);
+    let app: bool = map
+        .get(Symbol::new(&env, "approve"))
+        .unwrap()
+        .into_val(&env);
+    let yes: u32 = map
+        .get(Symbol::new(&env, "yes_votes"))
+        .unwrap()
+        .into_val(&env);
+    let no: u32 = map
+        .get(Symbol::new(&env, "no_votes"))
+        .unwrap()
+        .into_val(&env);
+    assert_eq!(old_r, old_resolver);
+    assert_eq!(new_r, new_resolver);
+    assert_eq!(voter, r2);
+    assert!(app);
+    assert_eq!(yes, 1);
+    assert_eq!(no, 1);
+
+    // Vote 3: Yes-vote (approve = true) from resolver 3. Intermediate vote -> Ok(None).
+    let r3 = resolvers.get(3).unwrap();
+    let res3 = client.try_vote_rotation(&r3, &true);
+    assert_eq!(res3, Ok(Ok(None)));
+
+    let events = env.events().all().filter_by_contract(&contract_id);
+    let last_event = events.events().last().unwrap().clone();
+    let (topics, data) = match &last_event.body {
+        xdr::ContractEventBody::V0(body) => (&body.topics, &body.data),
+    };
+    let topic0 = Symbol::try_from_val(&env, topics.first().unwrap()).unwrap();
+    assert_eq!(topic0, Symbol::new(&env, "rotation_voted"));
+    let data_val = Val::try_from_val(&env, data).unwrap();
+    let map: soroban_sdk::Map<Symbol, Val> = data_val.into_val(&env);
+    let old_r: Address = map
+        .get(Symbol::new(&env, "old_resolver"))
+        .unwrap()
+        .into_val(&env);
+    let new_r: Address = map
+        .get(Symbol::new(&env, "new_resolver"))
+        .unwrap()
+        .into_val(&env);
+    let voter: Address = map
+        .get(Symbol::new(&env, "resolver"))
+        .unwrap()
+        .into_val(&env);
+    let app: bool = map
+        .get(Symbol::new(&env, "approve"))
+        .unwrap()
+        .into_val(&env);
+    let yes: u32 = map
+        .get(Symbol::new(&env, "yes_votes"))
+        .unwrap()
+        .into_val(&env);
+    let no: u32 = map
+        .get(Symbol::new(&env, "no_votes"))
+        .unwrap()
+        .into_val(&env);
+    assert_eq!(old_r, old_resolver);
+    assert_eq!(new_r, new_resolver);
+    assert_eq!(voter, r3);
+    assert!(app);
+    assert_eq!(yes, 2);
+    assert_eq!(no, 1);
+
+    // Vote 4: Yes-vote (approve = true) from resolver 4. Reaches 3/5 majority -> Ok(Some(true)).
+    // Emits RotationExecuted and ResolversUpdated, NOT RotationVoted.
+    let r4 = resolvers.get(4).unwrap();
+    let res4 = client.try_vote_rotation(&r4, &true);
+    assert_eq!(res4, Ok(Ok(Some(true))));
+
+    let events = env.events().all().filter_by_contract(&contract_id);
+    let event_list = events.events();
+    let executed_event = event_list.get(event_list.len() - 2).unwrap().clone();
+    let (topics, _) = match &executed_event.body {
+        xdr::ContractEventBody::V0(body) => (&body.topics, &body.data),
+    };
+    let topic0 = Symbol::try_from_val(&env, topics.first().unwrap()).unwrap();
+    assert_eq!(topic0, Symbol::new(&env, "rotation_executed"));
+
+    let resolvers_updated_event = event_list.last().unwrap().clone();
+    let (topics, _) = match &resolvers_updated_event.body {
+        xdr::ContractEventBody::V0(body) => (&body.topics, &body.data),
+    };
+    let topic0 = Symbol::try_from_val(&env, topics.first().unwrap()).unwrap();
+    assert_eq!(topic0, Symbol::new(&env, "resolvers_updated"));
+}
+
 #[test]
 fn test_rotation_vote_twice_fails() {
     let f = Fixture::new();