npm - @snapshot-labs/snapshot.js - Versions diffs - 0.12.52 → 0.12.53 - Mend

@snapshot-labs/snapshot.js 0.12.52 → 0.12.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/snapshot.cjs.js +78 -34
package/dist/snapshot.esm.js +78 -34
package/dist/snapshot.min.js +1 -1
package/package.json +1 -1
package/src/voting/__snapshots__/copeland.spec.js.snap +66 -33
package/src/voting/copeland.spec.js +101 -0
package/src/voting/copeland.ts +125 -34

package/dist/snapshot.cjs.js CHANGED Viewed

@@ -3976,36 +3976,46 @@ class CopelandVoting {
         const validVotes = this.getValidVotes();
         const choicesCount = this.proposal.choices.length;
         const pairwiseComparisons = Array.from({ length: choicesCount }, () => Array(choicesCount).fill(0));
+        const totalVotingPower = this.getScoresTotal();
         // 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;
+            for (let currentRank = 0; currentRank < vote.choice.length; currentRank++) {
+                for (let nextRank = currentRank + 1; nextRank < vote.choice.length; nextRank++) {
+                    const preferredChoice = vote.choice[currentRank] - 1;
+                    const lowerChoice = vote.choice[nextRank] - 1;
+                    pairwiseComparisons[preferredChoice][lowerChoice] += vote.balance;
+                    pairwiseComparisons[lowerChoice][preferredChoice] -= 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]++;
+        let totalCopelandScore = 0;
+        for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+            for (let opponentIndex = 0; opponentIndex < choicesCount; opponentIndex++) {
+                if (choiceIndex !== opponentIndex) {
+                    const comparison = pairwiseComparisons[choiceIndex][opponentIndex];
+                    if (comparison > 0) {
+                        scores[choiceIndex]++;
                     }
-                    else if (pairwiseComparisons[i][j] < 0) {
-                        scores[j]++;
+                    else if (comparison < 0) {
+                        scores[opponentIndex]++;
                     }
                     else {
-                        scores[i] += 0.5;
-                        scores[j] += 0.5;
+                        scores[choiceIndex] += 0.5;
+                        scores[opponentIndex] += 0.5;
                     }
                 }
             }
         }
-        return scores;
+        // Calculate total Copeland score for normalization
+        totalCopelandScore = scores.reduce((sum, score) => sum + score, 0);
+        // Normalize scores to distribute voting power
+        if (totalCopelandScore > 0) {
+            return scores.map((score) => (score / totalCopelandScore) * totalVotingPower);
+        }
+        // If no clear winners, distribute power equally
+        return scores.map(() => totalVotingPower / choicesCount);
     }
     // Calculates the Copeland scores for each choice, broken down by strategy
     getScoresByStrategy() {
@@ -4013,40 +4023,74 @@ class CopelandVoting {
         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 total voting power per strategy
+        const strategyTotals = Array(strategiesCount).fill(0);
+        for (const vote of validVotes) {
+            for (let i = 0; i < strategiesCount; i++) {
+                strategyTotals[i] += vote.scores[i];
+            }
+        }
         // 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];
+            for (let currentRank = 0; currentRank < vote.choice.length; currentRank++) {
+                for (let nextRank = currentRank + 1; nextRank < vote.choice.length; nextRank++) {
+                    const preferredChoice = vote.choice[currentRank] - 1;
+                    const lowerChoice = vote.choice[nextRank] - 1;
+                    for (let strategyIndex = 0; strategyIndex < strategiesCount; strategyIndex++) {
+                        pairwiseComparisons[preferredChoice][lowerChoice][strategyIndex] +=
+                            vote.scores[strategyIndex];
+                        pairwiseComparisons[lowerChoice][preferredChoice][strategyIndex] -=
+                            vote.scores[strategyIndex];
                     }
                 }
             }
         }
         // 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]++;
+        for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+            for (let opponentIndex = 0; opponentIndex < choicesCount; opponentIndex++) {
+                if (choiceIndex !== opponentIndex) {
+                    for (let strategyIndex = 0; strategyIndex < strategiesCount; strategyIndex++) {
+                        const comparison = pairwiseComparisons[choiceIndex][opponentIndex][strategyIndex];
+                        if (comparison > 0) {
+                            scores[choiceIndex][strategyIndex]++;
                         }
-                        else if (pairwiseComparisons[i][j][s] < 0) {
-                            scores[j][s]++;
+                        else if (comparison < 0) {
+                            scores[opponentIndex][strategyIndex]++;
                         }
                         else {
-                            scores[i][s] += 0.5;
-                            scores[j][s] += 0.5;
+                            scores[choiceIndex][strategyIndex] += 0.5;
+                            scores[opponentIndex][strategyIndex] += 0.5;
                         }
                     }
                 }
             }
         }
-        return scores;
+        // Normalize scores by strategy to distribute voting power
+        const normalizedScores = Array.from({ length: choicesCount }, () => Array(strategiesCount).fill(0));
+        for (let strategyIndex = 0; strategyIndex < strategiesCount; strategyIndex++) {
+            // Calculate total Copeland score for this strategy
+            let totalCopelandScore = 0;
+            for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+                totalCopelandScore += scores[choiceIndex][strategyIndex];
+            }
+            // Normalize scores to distribute voting power for this strategy
+            if (totalCopelandScore > 0) {
+                for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+                    normalizedScores[choiceIndex][strategyIndex] =
+                        (scores[choiceIndex][strategyIndex] / totalCopelandScore) *
+                            strategyTotals[strategyIndex];
+                }
+            }
+            else if (strategyTotals[strategyIndex] > 0) {
+                // If no clear winners, distribute power equally for this strategy
+                for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+                    normalizedScores[choiceIndex][strategyIndex] =
+                        strategyTotals[strategyIndex] / choicesCount;
+                }
+            }
+        }
+        return normalizedScores;
     }
     // Calculates the total score (sum of all valid vote balances)
     getScoresTotal() {

package/dist/snapshot.esm.js CHANGED Viewed

@@ -3966,36 +3966,46 @@ class CopelandVoting {
         const validVotes = this.getValidVotes();
         const choicesCount = this.proposal.choices.length;
         const pairwiseComparisons = Array.from({ length: choicesCount }, () => Array(choicesCount).fill(0));
+        const totalVotingPower = this.getScoresTotal();
         // 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;
+            for (let currentRank = 0; currentRank < vote.choice.length; currentRank++) {
+                for (let nextRank = currentRank + 1; nextRank < vote.choice.length; nextRank++) {
+                    const preferredChoice = vote.choice[currentRank] - 1;
+                    const lowerChoice = vote.choice[nextRank] - 1;
+                    pairwiseComparisons[preferredChoice][lowerChoice] += vote.balance;
+                    pairwiseComparisons[lowerChoice][preferredChoice] -= 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]++;
+        let totalCopelandScore = 0;
+        for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+            for (let opponentIndex = 0; opponentIndex < choicesCount; opponentIndex++) {
+                if (choiceIndex !== opponentIndex) {
+                    const comparison = pairwiseComparisons[choiceIndex][opponentIndex];
+                    if (comparison > 0) {
+                        scores[choiceIndex]++;
                     }
-                    else if (pairwiseComparisons[i][j] < 0) {
-                        scores[j]++;
+                    else if (comparison < 0) {
+                        scores[opponentIndex]++;
                     }
                     else {
-                        scores[i] += 0.5;
-                        scores[j] += 0.5;
+                        scores[choiceIndex] += 0.5;
+                        scores[opponentIndex] += 0.5;
                     }
                 }
             }
         }
-        return scores;
+        // Calculate total Copeland score for normalization
+        totalCopelandScore = scores.reduce((sum, score) => sum + score, 0);
+        // Normalize scores to distribute voting power
+        if (totalCopelandScore > 0) {
+            return scores.map((score) => (score / totalCopelandScore) * totalVotingPower);
+        }
+        // If no clear winners, distribute power equally
+        return scores.map(() => totalVotingPower / choicesCount);
     }
     // Calculates the Copeland scores for each choice, broken down by strategy
     getScoresByStrategy() {
@@ -4003,40 +4013,74 @@ class CopelandVoting {
         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 total voting power per strategy
+        const strategyTotals = Array(strategiesCount).fill(0);
+        for (const vote of validVotes) {
+            for (let i = 0; i < strategiesCount; i++) {
+                strategyTotals[i] += vote.scores[i];
+            }
+        }
         // 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];
+            for (let currentRank = 0; currentRank < vote.choice.length; currentRank++) {
+                for (let nextRank = currentRank + 1; nextRank < vote.choice.length; nextRank++) {
+                    const preferredChoice = vote.choice[currentRank] - 1;
+                    const lowerChoice = vote.choice[nextRank] - 1;
+                    for (let strategyIndex = 0; strategyIndex < strategiesCount; strategyIndex++) {
+                        pairwiseComparisons[preferredChoice][lowerChoice][strategyIndex] +=
+                            vote.scores[strategyIndex];
+                        pairwiseComparisons[lowerChoice][preferredChoice][strategyIndex] -=
+                            vote.scores[strategyIndex];
                     }
                 }
             }
         }
         // 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]++;
+        for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+            for (let opponentIndex = 0; opponentIndex < choicesCount; opponentIndex++) {
+                if (choiceIndex !== opponentIndex) {
+                    for (let strategyIndex = 0; strategyIndex < strategiesCount; strategyIndex++) {
+                        const comparison = pairwiseComparisons[choiceIndex][opponentIndex][strategyIndex];
+                        if (comparison > 0) {
+                            scores[choiceIndex][strategyIndex]++;
                         }
-                        else if (pairwiseComparisons[i][j][s] < 0) {
-                            scores[j][s]++;
+                        else if (comparison < 0) {
+                            scores[opponentIndex][strategyIndex]++;
                         }
                         else {
-                            scores[i][s] += 0.5;
-                            scores[j][s] += 0.5;
+                            scores[choiceIndex][strategyIndex] += 0.5;
+                            scores[opponentIndex][strategyIndex] += 0.5;
                         }
                     }
                 }
             }
         }
-        return scores;
+        // Normalize scores by strategy to distribute voting power
+        const normalizedScores = Array.from({ length: choicesCount }, () => Array(strategiesCount).fill(0));
+        for (let strategyIndex = 0; strategyIndex < strategiesCount; strategyIndex++) {
+            // Calculate total Copeland score for this strategy
+            let totalCopelandScore = 0;
+            for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+                totalCopelandScore += scores[choiceIndex][strategyIndex];
+            }
+            // Normalize scores to distribute voting power for this strategy
+            if (totalCopelandScore > 0) {
+                for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+                    normalizedScores[choiceIndex][strategyIndex] =
+                        (scores[choiceIndex][strategyIndex] / totalCopelandScore) *
+                            strategyTotals[strategyIndex];
+                }
+            }
+            else if (strategyTotals[strategyIndex] > 0) {
+                // If no clear winners, distribute power equally for this strategy
+                for (let choiceIndex = 0; choiceIndex < choicesCount; choiceIndex++) {
+                    normalizedScores[choiceIndex][strategyIndex] =
+                        strategyTotals[strategyIndex] / choicesCount;
+                }
+            }
+        }
+        return normalizedScores;
     }
     // Calculates the total score (sum of all valid vote balances)
     getScoresTotal() {