@snapshot-labs/snapshot.js 0.12.52 → 0.12.54

package/dist/snapshot.cjs.js

@@ -2827,6 +2827,21 @@ var networks = {
 	},
 	start: 3525964,
 	logo: "ipfs://bafkreidqkleori7pmilesz4t52iebebaqf3oflzmoz646qfuaznanb3sgm"
+},
+	"4162": {
+	key: "4162",
+	name: "SX Rollup",
+	shortName: "mainnet",
+	chainId: 4162,
+	network: "mainnet",
+	multicall: "0x46997eb05F6A6A0bD5C140ABed09Cb02CA36b98c",
+	rpc: [
+	],
+	explorer: {
+		url: "https://explorerl2.sx.technology"
+	},
+	start: 1847483,
+	logo: "ipfs://bafkreibjkjx7evbw74e3sx65dtmcdr4g2rrbcorb2ivd6jz6yh6on6ozw4"
 },
 	"4200": {
 	key: "4200",
@@ -3976,36 +3991,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 +4038,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

@@ -2817,6 +2817,21 @@ var networks = {
 	},
 	start: 3525964,
 	logo: "ipfs://bafkreidqkleori7pmilesz4t52iebebaqf3oflzmoz646qfuaznanb3sgm"
+},
+	"4162": {
+	key: "4162",
+	name: "SX Rollup",
+	shortName: "mainnet",
+	chainId: 4162,
+	network: "mainnet",
+	multicall: "0x46997eb05F6A6A0bD5C140ABed09Cb02CA36b98c",
+	rpc: [
+	],
+	explorer: {
+		url: "https://explorerl2.sx.technology"
+	},
+	start: 1847483,
+	logo: "ipfs://bafkreibjkjx7evbw74e3sx65dtmcdr4g2rrbcorb2ivd6jz6yh6on6ozw4"
 },
 	"4200": {
 	key: "4200",
@@ -3966,36 +3981,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 +4028,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() {