anya-core 1.2.0

Enterprise-grade Bitcoin Infrastructure Platform
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use serde::{Deserialize, Serialize};
/// Quadratic Voting Implementation [AIS-3][BPC-3][DAO-3]
// [AIR-3][AIS-3][BPC-3][RES-3] Removed unused import: std::error::Error
use std::collections::HashMap;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum VotingError {
    #[error("Invalid vote: {0}")]
    InvalidVote(String),

    #[error("Voting not allowed: {0}")]
    VotingNotAllowed(String),

    #[error("Quadratic calculation error: {0}")]
    QuadraticError(String),
}

/// Vote on a proposal
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Vote {
    /// Proposal being voted on
    pub proposal_id: String,

    /// Voter identifier
    pub voter: String,

    /// Vote power (squared for quadratic voting)
    pub power: u64,

    /// Direction of vote
    pub direction: VoteDirection,

    /// Bitcoin signature (BPC-3 compliance)
    pub bitcoin_signature: Option<String>,
}

/// Direction of a vote
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum VoteDirection {
    /// Vote in favor
    For,

    /// Vote against
    Against,

    /// Abstain from voting
    Abstain,
}

/// Quadratic voting system for DAO governance
pub struct QuadraticVoting {
    /// Votes by proposal ID and voter
    votes: HashMap<String, HashMap<String, Vote>>,
}

impl Default for QuadraticVoting {
    fn default() -> Self {
        Self::new()
    }
}

impl QuadraticVoting {
    /// Create a new quadratic voting system
    pub fn new() -> Self {
        Self {
            votes: HashMap::new(),
        }
    }

    /// Cast a vote using quadratic voting rules
    pub fn cast_vote(&mut self, vote: Vote) -> Result<(), VotingError> {
        // Validate vote
        if vote.power == 0 {
            return Err(VotingError::InvalidVote(
                "Vote power cannot be zero".to_string(),
            ));
        }

        // For DAO-4, require Bitcoin signature
        if vote.bitcoin_signature.is_none() {
            return Err(VotingError::InvalidVote(
                "Bitcoin signature required for BPC-3 compliance".to_string(),
            ));
        }

        // Get or create proposal votes
        let proposal_votes = self.votes.entry(vote.proposal_id.clone()).or_default();

        // Store the vote
        proposal_votes.insert(vote.voter.clone(), vote);

        Ok(())
    }

    /// Calculate quadratic voting results for a proposal
    pub fn tally_votes(&self, proposal_id: &str) -> Result<VoteTally, VotingError> {
        let proposal_votes = self.votes.get(proposal_id).ok_or_else(|| {
            VotingError::InvalidVote(format!("No votes found for proposal {proposal_id}"))
        })?;

        let mut for_votes = 0.0;
        let mut against_votes = 0.0;
        let mut abstain_votes = 0.0;

        for vote in proposal_votes.values() {
            // Calculate quadratic vote power (square root of power)
            let quadratic_power = (vote.power as f64).sqrt();

            match vote.direction {
                VoteDirection::For => for_votes += quadratic_power,
                VoteDirection::Against => against_votes += quadratic_power,
                VoteDirection::Abstain => abstain_votes += quadratic_power,
            }
        }

        Ok(VoteTally {
            proposal_id: proposal_id.to_string(),
            for_votes,
            against_votes,
            abstain_votes,
            total_votes: proposal_votes.len(),
        })
    }
}

/// Results of a vote tally
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VoteTally {
    /// Proposal that was voted on
    pub proposal_id: String,

    /// Quadratic votes in favor
    pub for_votes: f64,

    /// Quadratic votes against
    pub against_votes: f64,

    /// Quadratic abstentions
    pub abstain_votes: f64,

    /// Total number of voters
    pub total_votes: usize,
}