updated voting contract

Author: Prometheo

contracts/voting/README.md

@@ -0,0 +1,113 @@
+# NEAR Voting Contract
+
+A flexible and secure voting system built on NEAR Protocol that supports multiple election types, voting mechanisms, and voter eligibility verification.
+
+## Purpose
+
+This contract enables the creation and management of various types of elections on the NEAR blockchain, supporting features like:
+- Multiple voting types (Simple, Weighted)
+- Different election formats (General, Pot-based)
+- Configurable voter eligibility (Open, List-based, Token-based)
+- Secure vote recording and tallying
+- Transparent election results
+
+## Key Features
+
+### Election Types
+- **General Elections**: Standard voting process with multiple candidates
+- **Pot Elections**: Elections with an associated prize pool
+
+### Voting Mechanisms
+- **Simple Voting**: One vote per voter per candidate
+- **Weighted Voting**: Voters can assign different weights to their votes (up to a maximum)
+
+### Voter Eligibility
+- **Open**: Anyone can vote
+- **List-based**: Voters must be on a predefined list on potlock's list contract.
+- **Token-based**: Voters must hold a minimum token balance (planned)
+- **Custom**: Customizable eligibility criteria through external contracts
+
+## Core Functions
+
+### Election Management
+
+```rust
+create_election(
+title: String,
+description: String,
+start_date: U64,
+end_date: U64,
+votes_per_voter: u32,
+voter_eligibility: String,
+voting_type: String,
+election_type: Value,
+candidates: Vec<AccountId>
+)
+```
+
+- Creates a new election with specified parameters
+- Requires deposit for creation
+
+### Candidate Operations
+
+```rust
+apply(election_id: u64)
+```
+- Allows accounts to apply as candidates
+- Available during nomination period
+
+### Voting Operations
+```rust
+vote(election_id: u64, vote: (AccountId, u32))
+```
+- Casts a vote for a candidate
+- Validates voter eligibility and voting rules
+
+### Query Methods
+```rust
+get_election(election_id: &ElectionId) -> Option<Election>
+get_voter_votes(election_id: &ElectionId, voter: &AccountId) -> Option<Vec<Vote>>
+get_election_vote_count(election_id: &ElectionId) -> u64
+get_candidate_vote_weight(election_id: &ElectionId, candidate_id: &AccountId) -> u64
+is_voting_period(election_id: &ElectionId) -> bool
+```
+
+## Usage
+
+### Deployment
+```bash
+near deploy --wasmFile target/near/voting_contract.wasm --accountId your-contract.near
+```
+
+### Initialize Contract
+```bash
+near call your-contract.near new '{"owner_id": "owner.near"}' --accountId owner.near
+```
+
+### Create Election
+```bash
+near call your-contract.near create_election '{
+  "title": "Test Election",
+  "description": "Test Description",
+  "start_date": "1234567890000000000",
+  "end_date": "1234567890000000000",
+  "votes_per_voter": 1,
+  "voter_eligibility": "Open",
+  "voting_type": "Simple",
+  "election_type": {"General": null},
+  "candidates": ["candidate1.near"]
+}' --accountId owner.near --deposit 1
+```
+
+## Testing
+
+Run the test suite:
+```bash
+cargo test
+```
+
+Key test cases cover:
+- Election creation and management
+- Voting mechanics
+- Eligibility verification
+- Result calculation

contracts/voting/out/main.wasm

@@ -1,6 +1,5 @@
-use near_sdk::json_types::U128;
 use crate::*;
-
+use near_sdk::json_types::U128;
 
 #[near(serializers=[borsh, json])]
 #[derive(Clone, PartialEq)]
@@ -11,8 +10,6 @@ pub enum ElectionType {
     Custom(String, Option<AccountId>),
 }
 
-
-
 #[near(serializers=[borsh, json])]
 #[derive(Clone, PartialEq)]
 pub enum ApplicationStatus {
@@ -25,10 +22,9 @@ pub enum ElectionPhase {
     Pending,
     Nomination,
     Voting,
-    Ended
+    Ended,
 }
 
-
 #[near(serializers=[borsh, json])]
 #[derive(Clone, PartialEq)]
 pub struct Candidate {
@@ -38,14 +34,13 @@ pub struct Candidate {
     pub application_date: U64,
 }
 
-
 #[near(serializers=[borsh, json])]
 #[derive(Clone, PartialEq)]
 pub enum EligibilityType {
     Open,
-    ListBased(AccountId, U128), // list contract and id
+    ListBased(AccountId, U128),  // list contract and id
     TokenBased(AccountId, U128), // Token contract and minimum balance
-    Custom(String), // Custom eligibility contract address
+    Custom(String),              // Custom eligibility contract address
 }
 
 #[near(serializers=[borsh, json])]
@@ -59,7 +54,6 @@ pub enum ElectionStatus {
     Cancelled,
 }
 
-
 #[near(serializers=[borsh, json])]
 #[derive(Clone, PartialEq)]
 pub struct Election {
@@ -93,11 +87,14 @@ impl Contract {
         voter_eligibility: EligibilityType,
         voting_type: VotingType,
         election_type: ElectionType,
-        candidates: Vec<AccountId>
+        candidates: Vec<AccountId>,
     ) -> ElectionId {
         self.assert_not_paused();
         self.assert_admin_or_owner();
-        assert!(start_date.0 < end_date.0, "Start date must be before end date");
+        assert!(
+            start_date.0 < end_date.0,
+            "Start date must be before end date"
+        );
         let initial_storage_usage = env::storage_usage();
 
         let election_id = self.election_counter;
@@ -124,12 +121,15 @@ impl Contract {
         let mut candidates_map: IterableMap<AccountId, Candidate> =
             IterableMap::new(StorageKey::Candidates { election_id });
         for candidate in candidates.clone() {
-            candidates_map.insert(candidate.clone(), Candidate {
-                account_id: candidate,
-                status: ApplicationStatus::Approved,
-                votes_received: 0,
-                application_date: U64(env::block_timestamp()),
-            });
+            candidates_map.insert(
+                candidate.clone(),
+                Candidate {
+                    account_id: candidate,
+                    status: ApplicationStatus::Approved,
+                    votes_received: 0,
+                    application_date: U64(env::block_timestamp_ms()),
+                },
+            );
         }
         self.candidates.insert(election_id, candidates_map);
 
@@ -148,8 +148,8 @@ impl Contract {
     #[payable]
     pub fn apply(&mut self, election_id: ElectionId) {
         // let election = self.elections.get(&election_id).expect("Election not found");
-        // println!("Nomination end date: {:?}", env::block_timestamp());
-        
+        // println!("Nomination end date: {:?}", env::block_timestamp_ms());
+
 
         // let applicant = env::predecessor_account_id();
         // // assert!(self.is_eligible_candidate(&election, &applicant), "Not eligible to be a candidate");
@@ -162,9 +162,9 @@ impl Contract {
         //         ApplicationStatus::Pending
         //     },
         //     votes_received: 0,
-        //     application_date: U64(env::block_timestamp()),
+        //     application_date: U64(env::block_timestamp_ms()),
         //     approval_date: if election.auto_approval {
-        //         Some(U64(env::block_timestamp()))
+        //         Some(U64(env::block_timestamp_ms()))
         //     } else {
         //         None
         //     },
@@ -184,7 +184,7 @@ impl Contract {
     // ) {
     //     // self.assert_not_paused();
     //     self.assert_admin_or_owner();
-        
+
     //     let election = self.elections.get(&election_id).expect("Election not found");
     //     let mut candidates_map = self.candidates
     //         .get_mut(&election_id)
@@ -205,9 +205,9 @@ impl Contract {
     //             account_id: candidate,
     //             status: ApplicationStatus::Approved,
     //             votes_received: 0,
-    //             application_date: U64(env::block_timestamp()),
+    //             application_date: U64(env::block_timestamp_ms()),
     //         };
-            
+
     //         candidates_map.insert(candidate.account_id.clone(), candidate);
 
     //     }
@@ -216,7 +216,6 @@ impl Contract {
     //     // candidates_map.insert(applicant, candidate);
     //     // // self.candidates.insert(election_id, &candidates_map);
 
-
     //     self.candidates.insert(election_id, candidates_map);
 
     //     // Refund excess deposit
@@ -235,16 +234,24 @@ impl Contract {
 
     //     candidate.status = status;
     //     if matches!(candidate.status, ApplicationStatus::Approved) {
-    //         candidate.approval_date = Some(U64(env::block_timestamp()));
+    //         candidate.approval_date = Some(U64(env::block_timestamp_ms()));
     //     }
     // }
 
-    pub fn get_elections(&self, from_index: Option<u128>, limit: Option<u128>,) -> Vec<Election> {
+    pub fn get_elections(&self, from_index: Option<u128>, limit: Option<u128>) -> Vec<Election> {
         let start_index = from_index.unwrap_or_default();
-        assert!(start_index < self.election_counter as u128, "Invalid start index");
+        assert!(
+            start_index < self.election_counter as u128,
+            "Invalid start index"
+        );
         let limit = limit.map(|v| v as usize).unwrap_or(usize::MAX);
 
-        self.elections.iter().map(|(_, election)| election.clone()).skip(start_index as usize).take(limit).collect()
+        self.elections
+            .iter()
+            .map(|(_, election)| election.clone())
+            .skip(start_index as usize)
+            .take(limit)
+            .collect()
     }
 
     pub fn get_election(&self, election_id: &ElectionId) -> Option<Election> {
@@ -254,15 +261,15 @@ impl Contract {
     /// Returns whether an election is currently in the voting period
     pub fn is_voting_period(&self, election_id: &ElectionId) -> bool {
         self.elections.get(election_id).map_or(false, |election| {
-            let now = env::block_timestamp();
+            let now = env::block_timestamp_ms();
             now >= election.start_date.0 && now < election.end_date.0
         })
     }
 
     /// Returns whether an election has ended
     pub fn is_election_ended(&self, election_id: &ElectionId) -> bool {
         self.elections.get(election_id).map_or(false, |election| {
-            env::block_timestamp() >= election.end_date.0
+            env::block_timestamp_ms() >= election.end_date.0
         })
     }
 
@@ -277,25 +284,21 @@ impl Contract {
 
     /// Returns all active elections (in nomination or voting period)
     pub fn get_active_elections(&self) -> Vec<(ElectionId, Election)> {
-        let now = env::block_timestamp();
+        let now = env::block_timestamp_ms();
         self.elections
             .iter()
-            .filter(|(_, election)| {
-                now >= election.start_date.0 && now < election.end_date.0
-            })
+            .filter(|(_, election)| now >= election.start_date.0 && now < election.end_date.0)
             .map(|(id, election)| (*id, election.clone()))
             .collect()
     }
 
     /// Returns the current phase of an election
     pub fn get_election_phase(&self, election_id: &ElectionId) -> Option<ElectionPhase> {
         self.elections.get(election_id).map(|election| {
-            let now = env::block_timestamp();
+            let now = env::block_timestamp_ms();
             if now < election.start_date.0 {
                 ElectionPhase::Pending
-            } else if now < election.end_date.0 {
-                ElectionPhase::Nomination
-            } else if now < election.end_date.0 {
+            } else if now >= election.start_date.0 && now < election.end_date.0 {
                 ElectionPhase::Voting
             } else {
                 ElectionPhase::Ended
@@ -304,27 +307,27 @@ impl Contract {
     }
 
     pub fn get_election_candidates(&self, election_id: ElectionId) -> Vec<Candidate> {
-        let candidates_map = self.candidates
+        let candidates_map = self
+            .candidates
             .get(&election_id)
             .expect("Election not found");
-        
+
         candidates_map.values().cloned().collect()
     }
 
     pub fn get_election_votes(&self, election_id: ElectionId) -> Vec<Vote> {
-        let votes_map = self.votes
-            .get(&election_id)
-            .expect("Election not found");
-        
-        votes_map.values()
+        let votes_map = self.votes.get(&election_id).expect("Election not found");
+
+        votes_map
+            .values()
             .flat_map(|votes| votes.iter().cloned())
             .collect()
     }
 
     /// Returns time remaining (in nanoseconds) in the current phase
     pub fn get_time_remaining(&self, election_id: &ElectionId) -> Option<u64> {
         self.elections.get(election_id).map(|election| {
-            let now = env::block_timestamp();
+            let now = env::block_timestamp_ms();
             if now < election.start_date.0 {
                 election.start_date.0 - now
             } else if now < election.end_date.0 {

contracts/voting/src/elections.rs

@@ -1,6 +1,5 @@
 use crate::*;
 
-
 pub const EVENT_JSON_PREFIX: &str = "EVENT_JSON:";
 /// source metadata update
 pub(crate) fn log_election_created_event(election: Election, candidates: &Vec<AccountId>) {
@@ -24,7 +23,6 @@ pub(crate) fn log_election_created_event(election: Election, candidates: &Vec<Ac
     );
 }
 
-
 pub(crate) fn log_vote_event(election_id: ElectionId, vote: (AccountId, u32)) {
     env::log_str(
         format!(