fix(service): add timestamp to events, update config setup, refactor proposal type (#4)

* feat(event): add timestamp into default service

* Enhance ConsensusEvent enum by adding PartialEq and Eq traits for improved comparison capabilities.

* Implement get_proposal_config method and enhance ConsensusConfig with new configuration methods

- Added `get_proposal_config` method in `service.rs` to retrieve the consensus configuration for a specific proposal.
- Introduced new methods in `ConsensusConfig` for setting timeout, threshold, and liveness criteria, improving configurability.
- Updated tests to ensure that proposal configurations correctly preserve timeout overrides and validate dynamic max rounds logic.

* Refactor Proposal to use Vec<u8> for payload instead of String.

Author: seemenkina

src/protos/messages/v1/consensus.proto

@@ -4,7 +4,7 @@ package consensus.v1;
 // Proposal represents a consensus proposal that needs voting
 message Proposal {
     string name = 10;                   // Proposal name
-    string payload = 11;                // Payload with the proposal data
+    bytes payload = 11;                // Payload with the proposal data
     uint32 proposal_id = 12;            // Unique identifier of the proposal
     bytes proposal_owner = 13;          // Public key of the creator 
     repeated Vote votes = 14;           // Vote list in the proposal

src/service.rs

@@ -10,7 +10,7 @@ use crate::{
     session::{ConsensusConfig, ConsensusSession, ConsensusState},
     storage::{ConsensusStorage, InMemoryConsensusStorage},
     types::{ConsensusEvent, SessionTransition},
-    utils::{calculate_consensus_result, has_sufficient_votes},
+    utils::{calculate_consensus_result, current_timestamp, has_sufficient_votes},
 };
 /// The main service that handles proposals, votes, and consensus.
 ///
@@ -147,6 +147,16 @@ where
         Ok(Some(result))
     }
 
+    /// Get the resolved per-proposal consensus configuration for an existing session.
+    pub async fn get_proposal_config(
+        &self,
+        scope: &Scope,
+        proposal_id: u32,
+    ) -> Result<ConsensusConfig, ConsensusError> {
+        let session = self.get_session(scope, proposal_id).await?;
+        Ok(session.config)
+    }
+
     /// Get all proposals that have reached consensus, along with their results.
     ///
     /// Returns a map from proposal ID to result (`true` for YES, `false` for NO).
@@ -270,6 +280,9 @@ where
         proposal: Option<&Proposal>,
     ) -> Result<ConsensusConfig, ConsensusError> {
         // 1. If explicit config override exists, use it as base
+        // NOTE: if a per-proposal override is provided, we should not stomp its timeout
+        // from the proposal's expiration fields (the caller explicitly chose it).
+        let has_explicit_override = proposal_override.is_some();
         let base_config = if let Some(override_config) = proposal_override {
             override_config
         } else if let Some(scope_config) = self.storage.get_scope_config(scope).await? {
@@ -280,8 +293,11 @@ where
 
         // 2. Apply proposal field overrides if proposal is provided
         if let Some(prop) = proposal {
-            // Calculate timeout from expiration_timestamp (absolute timestamp) - timestamp (creation time)
-            let timeout_seconds = if prop.expiration_timestamp > prop.timestamp {
+            // Calculate timeout from expiration_timestamp (absolute timestamp) - timestamp (creation time),
+            // unless an explicit override was supplied.
+            let timeout_seconds = if has_explicit_override {
+                base_config.consensus_timeout()
+            } else if prop.expiration_timestamp > prop.timestamp {
                 Duration::from_secs(prop.expiration_timestamp - prop.timestamp)
             } else {
                 base_config.consensus_timeout()
@@ -342,12 +358,19 @@ where
                     ConsensusEvent::ConsensusReached {
                         proposal_id,
                         result: consensus_result,
+                        timestamp: current_timestamp()?,
                     },
                 );
                 Ok(consensus_result)
             }
             None => {
-                self.emit_event(scope, ConsensusEvent::ConsensusFailed { proposal_id });
+                self.emit_event(
+                    scope,
+                    ConsensusEvent::ConsensusFailed {
+                        proposal_id,
+                        timestamp: current_timestamp()?,
+                    },
+                );
                 Err(ConsensusError::InsufficientVotesAtTimeout)
             }
         }
@@ -423,6 +446,7 @@ where
                 ConsensusEvent::ConsensusReached {
                     proposal_id,
                     result,
+                    timestamp: current_timestamp().unwrap_or(0),
                 },
             );
         }

src/session.rs

@@ -66,12 +66,24 @@ impl ConsensusConfig {
         ConsensusConfig::from(NetworkType::Gossipsub)
     }
 
-    pub fn set_up_rounds(&mut self, max_rounds: u32) -> Result<(), ConsensusError> {
-        if max_rounds == 0 {
-            return Err(ConsensusError::InvalidMaxRounds);
-        }
-        self.max_rounds = max_rounds;
-        Ok(())
+    /// Set consensus timeout (validated) and return the updated config.
+    pub fn with_timeout(mut self, consensus_timeout: Duration) -> Result<Self, ConsensusError> {
+        crate::utils::validate_timeout(consensus_timeout)?;
+        self.consensus_timeout = consensus_timeout;
+        Ok(self)
+    }
+
+    /// Set consensus threshold (validated) and return the updated config.
+    pub fn with_threshold(mut self, consensus_threshold: f64) -> Result<Self, ConsensusError> {
+        crate::utils::validate_threshold(consensus_threshold)?;
+        self.consensus_threshold = consensus_threshold;
+        Ok(self)
+    }
+
+    /// Set liveness criteria and return the updated config.
+    pub fn with_liveness_criteria(mut self, liveness_criteria: bool) -> Self {
+        self.liveness_criteria = liveness_criteria;
+        self
     }
 
     /// Create a new ConsensusConfig with the given values.
@@ -381,8 +393,7 @@ mod tests {
         .unwrap();
 
         let proposal = request.into_proposal().unwrap();
-        let mut config = ConsensusConfig::gossipsub();
-        config.set_up_rounds(2).unwrap();
+        let config = ConsensusConfig::gossipsub();
         let mut session = ConsensusSession::new(proposal, config);
 
         // Round 1 -> Round 2 (first vote)
@@ -409,12 +420,14 @@ mod tests {
 
     #[tokio::test]
     async fn enforce_max_rounds_p2p() {
-        // P2P: max_rounds = 2 means maximum 2 votes
-        // Round 1 = 0 votes, Round 2 = 1 vote, Round 3 = 2 votes
-        // So max_rounds = 2 allows up to round 3 (2 votes)
+        // P2P defaults: max_rounds = 0 triggers dynamic calculation based on expected voters.
+        // For threshold=2/3 and expected_voters=5, max_round_limit = ceil(2n/3) = 4 votes.
+        // Round 1 = 0 votes, Round 2 = 1 vote, ... Round 5 = 4 votes.
         let signer1 = PrivateKeySigner::random();
         let signer2 = PrivateKeySigner::random();
         let signer3 = PrivateKeySigner::random();
+        let signer4 = PrivateKeySigner::random();
+        let signer5 = PrivateKeySigner::random();
 
         let request = CreateProposalRequest::new(
             "Test".into(),
@@ -427,8 +440,7 @@ mod tests {
         .unwrap();
 
         let proposal = request.into_proposal().unwrap();
-        let mut config = ConsensusConfig::p2p();
-        config.set_up_rounds(2).unwrap();
+        let config = ConsensusConfig::p2p();
         let mut session = ConsensusSession::new(proposal, config);
 
         // Round 1 -> Round 2 (first vote, 1 vote total)
@@ -443,9 +455,21 @@ mod tests {
         assert_eq!(session.proposal.round, 3);
         assert_eq!(session.votes.len(), 2);
 
-        // Third vote would be round 4 (3 votes total), which exceeds max_rounds = 2
+        // Round 3 -> Round 4 (third vote, 3 votes total) - should succeed
         let vote3 = build_vote(&session.proposal, true, signer3).await.unwrap();
-        let err = session.add_vote(vote3).unwrap_err();
+        session.add_vote(vote3).unwrap();
+        assert_eq!(session.proposal.round, 4);
+        assert_eq!(session.votes.len(), 3);
+
+        // Round 4 -> Round 5 (fourth vote, 4 votes total) - should succeed (dynamic limit = 4)
+        let vote4 = build_vote(&session.proposal, true, signer4).await.unwrap();
+        session.add_vote(vote4).unwrap();
+        assert_eq!(session.proposal.round, 5);
+        assert_eq!(session.votes.len(), 4);
+
+        // Fifth vote would exceed dynamic max_round_limit (=4 votes)
+        let vote5 = build_vote(&session.proposal, true, signer5).await.unwrap();
+        let err = session.add_vote(vote5).unwrap_err();
         assert!(matches!(err, ConsensusError::MaxRoundsExceeded));
     }
 }

src/types.rs

@@ -6,12 +6,16 @@ use crate::{
     utils::{current_timestamp, generate_id, validate_expected_voters_count, validate_timeout},
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConsensusEvent {
     /// Consensus was reached! The proposal has a final result (yes or no).
-    ConsensusReached { proposal_id: u32, result: bool },
+    ConsensusReached {
+        proposal_id: u32,
+        result: bool,
+        timestamp: u64,
+    },
     /// Consensus failed - not enough votes were collected before the timeout.
-    ConsensusFailed { proposal_id: u32 },
+    ConsensusFailed { proposal_id: u32, timestamp: u64 },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -27,7 +31,7 @@ pub struct CreateProposalRequest {
     /// A short name for the proposal (e.g., "Upgrade to v2").
     pub name: String,
     /// Additional details about what's being voted on.
-    pub payload: String,
+    pub payload: Vec<u8>,
     /// The address (public key bytes) of whoever created this proposal.
     pub proposal_owner: Vec<u8>,
     /// How many people are expected to vote (used to calculate consensus threshold).
@@ -42,7 +46,7 @@ impl CreateProposalRequest {
     /// Create a new proposal request with validation.
     pub fn new(
         name: String,
-        payload: String,
+        payload: Vec<u8>,
         proposal_owner: Vec<u8>,
         expected_voters_count: u32,
         expiration_timestamp: u64,

tests/concurrency_tests.rs

@@ -10,7 +10,7 @@ use hashgraph_like_consensus::{
 
 const SCOPE: &str = "concurrency_scope";
 const PROPOSAL_NAME: &str = "Concurrency Test";
-const PROPOSAL_PAYLOAD: &str = "";
+const PROPOSAL_PAYLOAD: Vec<u8> = vec![];
 
 const EXPIRATION: u64 = 120;
 const EXPIRATION_WAIT_TIME: u64 = 100;
@@ -39,7 +39,7 @@ async fn test_concurrent_vote_casting() {
             &scope,
             CreateProposalRequest::new(
                 PROPOSAL_NAME.to_string(),
-                PROPOSAL_PAYLOAD.to_string(),
+                PROPOSAL_PAYLOAD,
                 owner_bytes(&proposal_owner),
                 EXPECTED_VOTERS_COUNT_10,
                 EXPIRATION,
@@ -98,7 +98,7 @@ async fn test_concurrent_proposal_operations() {
                     &scope_clone,
                     CreateProposalRequest::new(
                         format!("Proposal {i}"),
-                        PROPOSAL_PAYLOAD.to_string(),
+                        PROPOSAL_PAYLOAD,
                         owner_bytes(&proposal_owner),
                         EXPECTED_VOTERS_COUNT_3,
                         EXPIRATION,
@@ -136,7 +136,7 @@ async fn test_concurrent_duplicate_vote_rejection() {
             &scope,
             CreateProposalRequest::new(
                 PROPOSAL_NAME.to_string(),
-                PROPOSAL_PAYLOAD.to_string(),
+                PROPOSAL_PAYLOAD,
                 owner_bytes(&proposal_owner),
                 EXPECTED_VOTERS_COUNT_3,
                 EXPIRATION,