Expanding cwd-proposal-multiple

[discoverdefiteam]

Idea: An option to have a proposal which let governance members allocate points to multiple possible options. This would give the ability to propose to allocate a number points within a range for a number of elements within the proposal.

Inspiration: This idea comes from an event that is being hosted, where guest bring entries that are being judged on 4 distinct elements of each entry. All judges are added to a cw4 based DAO, & event admin create the proposals for guest to vote on.

Possible Solution:

• Instead of the cwd-proposal-multiple where users may select choice(s) from multiple, users should be able to set a value (or multiple, distinct values)
• A way to tally the sum of each of these values

Question: How would one go about realizing this?

[blue-note]

this is an interesting idea! I think one could go about this by forking the multiple-choice contract and, as you said, allowing users to submit a list of point-allocations rather than 'yes / no' votes.

another question: would ranked choice voting suffice for this use case? you don't get point allocation with that, but you get to rank the choices (as the name implies)

[blue-note]

can you elaborate on what this means "it might be better to let people instantiate new proposals that require additional objects" ?

[discoverdefiteam]

yeah absolutely, i might have missused the word object 😅

What we would like to do is build & upload a cw-proposal-multiple-tally that lets anyone instantiate a contract that has a specific number of elements a proposal can have voters allocate points to, within a set range.
(Instead of the opposite, which is hard coding the number of elements a proposal can have)

[blue-note]

sounds good! I think you can still use the existing choices that is passed in when creating a multichoice proposal:

dao-contracts/contracts/proposal/cwd-proposal-multiple/src/msg.rs

Line 51 in 0029c06

choices: MultipleChoiceOptions,

What you would need to do is to modify the ExecuteVote mechanics to allow people to pass in a vec of points to allocate to each choice.

Another question; what would be the criteria for such a proposal to pass?

[discoverdefiteam]

oh nice, i think we can have our criteria be a traditional quorum of the number of expected voters.

[discoverdefiteam]

Heres a breakdown of the changes that we think might be needed!

These are also a few things would be needed, but not confident:

• How to check how many options each proposal should have
• How to sum each options points allocated (note this is not voting weight)
• How to sum all of the total points for each option within a proposal.
• Ensure that the sum of all proposal option does not exceed the maximum expected value.

cwd-proposal-multiple

msg.rs

• add a range of points and a maximum amount of elements within InstantiateMsg to allow us to prevent unwanted actions

pub struct InstantiateMsg {
    /// The number of elements in the proposal
    pub number_of_elements: u32,
    /// The minimum amount of points any 1 element can be given 
    pub points_range_min: u32,
    // The maximum amount of points any 1 element can be given
    pub points_range_max: u32,
    }

pub enum ExecuteMsg {
    Propose{}
    Vote{
    /// The proposal_id to vote on.
    proposal_id: u64,
    /// The option_id of the proposal to vote on 
    option_id: u64,
    /// The senders position on the proposal.
    vote: MultipleChoiceVote,
    }
}

pub enum QueryMsg {

     /// List the points of any option_id, for a given proposal_id
     ListOptionsForProposal {
        proposal_id: Option<u64>,
        option_id: Option<u64>,
    },
     /// Returns a  voters position on a specific option_id within a proposal_id
     GetOptionVote { 
        proposal_id: u64, 
        option_id: u64, 
        voter: String}
    /// List all votes of a given option_id, within a given proposal_id
    ListOptionsVotes {
        proposal_id: u64,
        option_id: u64,
        start_after: Option<u64>,
        limit: Option<u64>,
        }

proposal.rs

pub struct MultipleChoiceProposal {
    pub custom: Custom,
}

// We do not need to check & error on elements for option vote for our use case, but might in case of scenario where voting weight of multiple options are the same. 


 if let Some(max_weight) = self.votes.vote_weights.iter().max_by(|&a, &b| a.cmp(b)) {
                    let top_choices: Vec<(usize, &Uint128)> = self
                        .votes
                        .vote_weights
                        .iter()
                        .enumerate()
                        .filter(|x| x.1 == max_weight)
                        .collect();
 }

query.rs

pub struct VoteInfo {
    /// The element id to be voted on.
    pub proposal_id: u64,
    pub option_id: u64,

}

cwd-voting

multiple_choice.rs

pub struct MultipleChoiceVote {
    // A vote indicates which element the user has selected.
    // A vote indicates which option the user has selected.
    pub option_id: u32,
    pub option_value: u32,
}
impl std::fmt::Display for MultipleChoiceVote {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.option_id);
        write!(f, "{}", self.option_value)
    }
}

pub struct MultipleChoiceVotes {

    pub vote_weights: Vec<Uint128>,
    pub option_values: Vec<Uint128>,
}
// Sum all of the option values for all values 
// Sum all of the option values for any one option

// Add a vote to the tally
    pub fn add_vote(&mut self, vote: MultipleChoiceVote, weight: Uint128) -> StdResult<()> {
        self.vote_weights[vote.option_id as usize] = self.vote_weights[vote.option_id as usize]
            .checked_add(weight)
            .map_err(StdError::overflow)?;
        self.option_values[vote.option_value as usize] = self.option_values[vote.option_value as usize]
            .checked_add(weight)
            .map_err(StdError::overflow)?;
        Ok(())
    }
// Remove a vote from the tally
    pub fn remove_vote(&mut self, vote: MultipleChoiceVote, weight: Uint128) -> StdResult<()> {
        self.vote_weights[vote.option_id as usize] = self.vote_weights[vote.option_id as usize]
            .checked_sub(weight)
            .map_err(StdError::overflow)?;
        self.option_values[vote.option_value as usize] = self.option_values[vote.option_value as usize]
            .checked_sub(weight)
            .map_err(StdError::overflow)?;
        Ok(())
    }
    pub fn zero(num_choices: usize) -> Self {
        Self {
            // TODO: Do we need to tally zero for every option value as well?
            vote_weights: vec![Uint128::zero(); num_choices],
            option_values: vec![Uint128::zero(); num_choices],
        }
    }
    

        pub struct CheckedMultipleChoiceOption {
    // This is the index of the option in both the vote_weights and proposal.choices vectors.
    // Workaround due to not being able to use HashMaps in Cosmwasm.
    pub index: u32,
    pub option_type: MultipleChoiceOptionType,
    pub option_points_count: Uint128,  //TODO: Add checks for the vote_weights of each element 
    pub title: String,
    pub description: String,
    pub msgs: Vec<CosmosMsg<Empty>>,

Let me know if this is butchered! lol