@snapshot-labs/snapshot.js 0.12.49 → 0.12.51

package/dist/snapshot.cjs.js

@@ -351,6 +351,8 @@ class Client {
     }
     proposal(web3, address, message) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!message.labels)
+                message.labels = [];
             if (!message.discussion)
                 message.discussion = '';
             if (!message.app)
@@ -1088,6 +1090,7 @@ var definitions$1 = {
 					"approval",
 					"ranked-choice",
 					"quadratic",
+					"copeland",
 					"weighted",
 					"custom",
 					"basic"
@@ -3942,6 +3945,121 @@ class RankedChoiceVoting {
     }
 }
 
+// CopelandVoting implements ranked choice voting using Copeland's method
+// This method compares each pair of choices and awards points based on pairwise victories
+class CopelandVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    // Validates if a vote choice is valid for the given proposal
+    // Allows partial ranking (not all choices need to be ranked)
+    static isValidChoice(voteChoice, proposalChoices) {
+        if (!Array.isArray(voteChoice) ||
+            voteChoice.length === 0 ||
+            voteChoice.length > proposalChoices.length ||
+            new Set(voteChoice).size !== voteChoice.length) {
+            return false;
+        }
+        return voteChoice.every((choice) => Number.isInteger(choice) &&
+            choice >= 1 &&
+            choice <= proposalChoices.length);
+    }
+    // Returns only the valid votes
+    getValidVotes() {
+        return this.votes.filter((vote) => CopelandVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    // Calculates the Copeland scores for each choice
+    getScores() {
+        const validVotes = this.getValidVotes();
+        const choicesCount = this.proposal.choices.length;
+        const pairwiseComparisons = Array.from({ length: choicesCount }, () => Array(choicesCount).fill(0));
+        // Calculate pairwise comparisons
+        for (const vote of validVotes) {
+            for (let i = 0; i < vote.choice.length; i++) {
+                for (let j = i + 1; j < vote.choice.length; j++) {
+                    const winner = vote.choice[i] - 1;
+                    const loser = vote.choice[j] - 1;
+                    pairwiseComparisons[winner][loser] += vote.balance;
+                    pairwiseComparisons[loser][winner] -= vote.balance;
+                }
+            }
+        }
+        // Calculate Copeland scores
+        const scores = Array(choicesCount).fill(0);
+        for (let i = 0; i < choicesCount; i++) {
+            for (let j = 0; j < choicesCount; j++) {
+                if (i !== j) {
+                    if (pairwiseComparisons[i][j] > 0) {
+                        scores[i]++;
+                    }
+                    else if (pairwiseComparisons[i][j] < 0) {
+                        scores[j]++;
+                    }
+                    else {
+                        scores[i] += 0.5;
+                        scores[j] += 0.5;
+                    }
+                }
+            }
+        }
+        return scores;
+    }
+    // Calculates the Copeland scores for each choice, broken down by strategy
+    getScoresByStrategy() {
+        const validVotes = this.getValidVotes();
+        const choicesCount = this.proposal.choices.length;
+        const strategiesCount = this.strategies.length;
+        const pairwiseComparisons = Array.from({ length: choicesCount }, () => Array.from({ length: choicesCount }, () => Array(strategiesCount).fill(0)));
+        // Calculate pairwise comparisons for each strategy
+        for (const vote of validVotes) {
+            for (let i = 0; i < vote.choice.length; i++) {
+                for (let j = i + 1; j < vote.choice.length; j++) {
+                    const winner = vote.choice[i] - 1;
+                    const loser = vote.choice[j] - 1;
+                    for (let s = 0; s < strategiesCount; s++) {
+                        pairwiseComparisons[winner][loser][s] += vote.scores[s];
+                        pairwiseComparisons[loser][winner][s] -= vote.scores[s];
+                    }
+                }
+            }
+        }
+        // Calculate Copeland scores for each strategy
+        const scores = Array.from({ length: choicesCount }, () => Array(strategiesCount).fill(0));
+        for (let i = 0; i < choicesCount; i++) {
+            for (let j = 0; j < choicesCount; j++) {
+                if (i !== j) {
+                    for (let s = 0; s < strategiesCount; s++) {
+                        if (pairwiseComparisons[i][j][s] > 0) {
+                            scores[i][s]++;
+                        }
+                        else if (pairwiseComparisons[i][j][s] < 0) {
+                            scores[j][s]++;
+                        }
+                        else {
+                            scores[i][s] += 0.5;
+                            scores[j][s] += 0.5;
+                        }
+                    }
+                }
+            }
+        }
+        return scores;
+    }
+    // Calculates the total score (sum of all valid vote balances)
+    getScoresTotal() {
+        return this.getValidVotes().reduce((total, vote) => total + vote.balance, 0);
+    }
+    // Returns a string representation of the selected choices
+    getChoiceString() {
+        return this.selected
+            .map((choice) => this.proposal.choices[choice - 1])
+            .join(', ');
+    }
+}
+
 function percentageOfTotal(i, values, total) {
     const reducedTotal = total.reduce((a, b) => a + b, 0);
     const percent = (values[i] / reducedTotal) * 100;
@@ -4014,6 +4132,7 @@ var voting = {
     approval: ApprovalVoting,
     quadratic: QuadraticVoting,
     'ranked-choice': RankedChoiceVoting,
+    copeland: CopelandVoting,
     weighted: WeightedVoting,
     basic: SingleChoiceVoting
 };

package/dist/snapshot.esm.js

@@ -341,6 +341,8 @@ class Client {
     }
     proposal(web3, address, message) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!message.labels)
+                message.labels = [];
             if (!message.discussion)
                 message.discussion = '';
             if (!message.app)
@@ -1078,6 +1080,7 @@ var definitions$1 = {
 					"approval",
 					"ranked-choice",
 					"quadratic",
+					"copeland",
 					"weighted",
 					"custom",
 					"basic"
@@ -3932,6 +3935,121 @@ class RankedChoiceVoting {
     }
 }
 
+// CopelandVoting implements ranked choice voting using Copeland's method
+// This method compares each pair of choices and awards points based on pairwise victories
+class CopelandVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    // Validates if a vote choice is valid for the given proposal
+    // Allows partial ranking (not all choices need to be ranked)
+    static isValidChoice(voteChoice, proposalChoices) {
+        if (!Array.isArray(voteChoice) ||
+            voteChoice.length === 0 ||
+            voteChoice.length > proposalChoices.length ||
+            new Set(voteChoice).size !== voteChoice.length) {
+            return false;
+        }
+        return voteChoice.every((choice) => Number.isInteger(choice) &&
+            choice >= 1 &&
+            choice <= proposalChoices.length);
+    }
+    // Returns only the valid votes
+    getValidVotes() {
+        return this.votes.filter((vote) => CopelandVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    // Calculates the Copeland scores for each choice
+    getScores() {
+        const validVotes = this.getValidVotes();
+        const choicesCount = this.proposal.choices.length;
+        const pairwiseComparisons = Array.from({ length: choicesCount }, () => Array(choicesCount).fill(0));
+        // Calculate pairwise comparisons
+        for (const vote of validVotes) {
+            for (let i = 0; i < vote.choice.length; i++) {
+                for (let j = i + 1; j < vote.choice.length; j++) {
+                    const winner = vote.choice[i] - 1;
+                    const loser = vote.choice[j] - 1;
+                    pairwiseComparisons[winner][loser] += vote.balance;
+                    pairwiseComparisons[loser][winner] -= vote.balance;
+                }
+            }
+        }
+        // Calculate Copeland scores
+        const scores = Array(choicesCount).fill(0);
+        for (let i = 0; i < choicesCount; i++) {
+            for (let j = 0; j < choicesCount; j++) {
+                if (i !== j) {
+                    if (pairwiseComparisons[i][j] > 0) {
+                        scores[i]++;
+                    }
+                    else if (pairwiseComparisons[i][j] < 0) {
+                        scores[j]++;
+                    }
+                    else {
+                        scores[i] += 0.5;
+                        scores[j] += 0.5;
+                    }
+                }
+            }
+        }
+        return scores;
+    }
+    // Calculates the Copeland scores for each choice, broken down by strategy
+    getScoresByStrategy() {
+        const validVotes = this.getValidVotes();
+        const choicesCount = this.proposal.choices.length;
+        const strategiesCount = this.strategies.length;
+        const pairwiseComparisons = Array.from({ length: choicesCount }, () => Array.from({ length: choicesCount }, () => Array(strategiesCount).fill(0)));
+        // Calculate pairwise comparisons for each strategy
+        for (const vote of validVotes) {
+            for (let i = 0; i < vote.choice.length; i++) {
+                for (let j = i + 1; j < vote.choice.length; j++) {
+                    const winner = vote.choice[i] - 1;
+                    const loser = vote.choice[j] - 1;
+                    for (let s = 0; s < strategiesCount; s++) {
+                        pairwiseComparisons[winner][loser][s] += vote.scores[s];
+                        pairwiseComparisons[loser][winner][s] -= vote.scores[s];
+                    }
+                }
+            }
+        }
+        // Calculate Copeland scores for each strategy
+        const scores = Array.from({ length: choicesCount }, () => Array(strategiesCount).fill(0));
+        for (let i = 0; i < choicesCount; i++) {
+            for (let j = 0; j < choicesCount; j++) {
+                if (i !== j) {
+                    for (let s = 0; s < strategiesCount; s++) {
+                        if (pairwiseComparisons[i][j][s] > 0) {
+                            scores[i][s]++;
+                        }
+                        else if (pairwiseComparisons[i][j][s] < 0) {
+                            scores[j][s]++;
+                        }
+                        else {
+                            scores[i][s] += 0.5;
+                            scores[j][s] += 0.5;
+                        }
+                    }
+                }
+            }
+        }
+        return scores;
+    }
+    // Calculates the total score (sum of all valid vote balances)
+    getScoresTotal() {
+        return this.getValidVotes().reduce((total, vote) => total + vote.balance, 0);
+    }
+    // Returns a string representation of the selected choices
+    getChoiceString() {
+        return this.selected
+            .map((choice) => this.proposal.choices[choice - 1])
+            .join(', ');
+    }
+}
+
 function percentageOfTotal(i, values, total) {
     const reducedTotal = total.reduce((a, b) => a + b, 0);
     const percent = (values[i] / reducedTotal) * 100;
@@ -4004,6 +4122,7 @@ var voting = {
     approval: ApprovalVoting,
     quadratic: QuadraticVoting,
     'ranked-choice': RankedChoiceVoting,
+    copeland: CopelandVoting,
     weighted: WeightedVoting,
     basic: SingleChoiceVoting
 };