/
useQuorum.ts
127 lines (109 loc) · 3.64 KB
/
useQuorum.ts
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
import { ExtendedSpace, Proposal, Results } from '@/helpers/interfaces';
import getProvider from '@snapshot-labs/snapshot.js/src/utils/provider';
import { BigNumber } from '@ethersproject/bignumber';
import { call } from '@snapshot-labs/snapshot.js/src/utils';
import { getSnapshots } from '@snapshot-labs/snapshot.js/src/utils/blockfinder';
interface QuorumProps {
space: ExtendedSpace;
proposal: Proposal;
results: Results;
}
const broviderUrl = import.meta.env.VITE_BROVIDER_URL;
export function useQuorum(props: QuorumProps) {
const loading = ref(false);
const quorum = ref(0);
const quorumType = ref('default');
const totalQuorumScore = computed(() => {
if (props.proposal.quorumType === 'optimistic') {
return props.results.scores
.filter((c, i) => i === 1)
.reduce((a, b) => a + b, 0);
}
const basicCount = props.space.plugins?.quorum?.basicCount;
if (basicCount && props.proposal.type === 'basic')
return props.results.scores
.filter((c, i) => basicCount.includes(i))
.reduce((a, b) => a + b, 0);
if (props.space.voting.hideAbstain && props.proposal.type === 'basic') {
return props.results.scores
.filter((c, i) => i !== 2)
.reduce((a, b) => a + b, 0);
}
if (props.results.scoresTotal) return props.results.scoresTotal;
return 0;
});
async function getQuorum(web3: any, quorumOptions: any, snapshot: string) {
if (props.proposal?.quorum) {
return props.proposal?.quorum;
}
if (!quorumOptions) return 0;
const { strategy } = quorumOptions;
const quorumModifier = quorumOptions.quorumModifier ?? 1;
switch (strategy) {
case 'static': {
return quorumOptions.total;
}
case 'balance': {
const { address, methodABI, decimals } = quorumOptions;
const blockTag = snapshot === 'latest' ? snapshot : parseInt(snapshot);
const votingPower = await call(
web3,
[methodABI],
[address, methodABI.name],
{ blockTag }
);
return (
BigNumber.from(votingPower)
.div(BigNumber.from(10).pow(decimals))
.toNumber() * quorumModifier
);
}
case 'multichainBalance': {
const { network, strategies } = quorumOptions;
const blocks = await getSnapshots(
network,
parseInt(snapshot),
web3,
strategies.map(s => s.network || network)
);
const requests: Promise<any>[] = strategies.map(s =>
call(
getProvider(s.network, { broviderUrl }),
[s.methodABI],
[s.address, s.methodABI.name],
{ blockTag: blocks[s.network] }
)
);
const results = await Promise.all(requests);
const totalBalance = results.reduce((total, ele, index) => {
if (index === 1) {
total = total.div(BigNumber.from(10).pow(strategies[0].decimals));
}
return total.add(
ele.div(BigNumber.from(10).pow(strategies[index].decimals))
);
});
return totalBalance.toNumber() * quorumModifier;
}
default:
throw new Error(`Unsupported quorum strategy: ${strategy}`);
}
}
async function loadQuorum() {
loading.value = true;
quorum.value = await getQuorum(
getProvider(props.space.network, { broviderUrl }),
props.space.plugins.quorum,
props.proposal.snapshot
);
quorumType.value = props.proposal.quorumType;
loading.value = false;
}
onMounted(() => loadQuorum());
return {
loadingQuorum: loading,
totalQuorumScore,
quorum,
quorumType
};
}