/
utils.go
155 lines (123 loc) · 3.43 KB
/
utils.go
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package odao
import (
"time"
"github.com/Seb369888/poolsea-go/dao"
tndao "github.com/Seb369888/poolsea-go/dao/trustednode"
"github.com/Seb369888/poolsea-go/rocketpool"
tnsettings "github.com/Seb369888/poolsea-go/settings/trustednode"
rptypes "github.com/Seb369888/poolsea-go/types"
"github.com/ethereum/go-ethereum/common"
"golang.org/x/sync/errgroup"
)
// Settings
const ProposalStatesBatchSize = 50
// Check if the proposal cooldown for an oracle node is active
func getProposalCooldownActive(rp *rocketpool.RocketPool, nodeAddress common.Address) (bool, error) {
// Data
var wg errgroup.Group
var lastProposalTime uint64
var proposalCooldown uint64
// Get last proposal time
wg.Go(func() error {
var err error
lastProposalTime, err = tndao.GetMemberLastProposalTime(rp, nodeAddress, nil)
return err
})
// Get proposal cooldown
wg.Go(func() error {
var err error
proposalCooldown, err = tnsettings.GetProposalCooldownTime(rp, nil)
return err
})
// Wait for data
if err := wg.Wait(); err != nil {
return false, err
}
// Return
return ((uint64(time.Now().Unix()) - lastProposalTime) < proposalCooldown), nil
}
// Check if a proposal for a node exists & is actionable
func getProposalIsActionable(rp *rocketpool.RocketPool, nodeAddress common.Address, proposalType string) (bool, error) {
// Data
var wg errgroup.Group
var proposalExecutedTime uint64
var actionTime uint64
// Get proposal executed time
wg.Go(func() error {
var err error
proposalExecutedTime, err = tndao.GetMemberProposalExecutedTime(rp, proposalType, nodeAddress, nil)
return err
})
// Get action window
wg.Go(func() error {
var err error
actionTime, err = tnsettings.GetProposalActionTime(rp, nil)
return err
})
// Wait for data
if err := wg.Wait(); err != nil {
return false, err
}
// Return
return (uint64(time.Now().Unix()) < (proposalExecutedTime + actionTime)), nil
}
// Check if members can leave the oracle DAO
func getMembersCanLeave(rp *rocketpool.RocketPool) (bool, error) {
// Data
var wg errgroup.Group
var memberCount uint64
var minMemberCount uint64
// Get member count
wg.Go(func() error {
var err error
memberCount, err = tndao.GetMemberCount(rp, nil)
return err
})
// Get min member count
wg.Go(func() error {
var err error
minMemberCount, err = tndao.GetMinimumMemberCount(rp, nil)
return err
})
// Wait for data
if err := wg.Wait(); err != nil {
return false, err
}
// Return
return (memberCount > minMemberCount), nil
}
// Get all proposal states
func getProposalStates(rp *rocketpool.RocketPool) ([]rptypes.ProposalState, error) {
// Get proposal IDs
proposalIds, err := dao.GetDAOProposalIDs(rp, "poolseaDAONodeTrustedProposals", nil)
if err != nil {
return []rptypes.ProposalState{}, err
}
// Load proposal states in batches
states := make([]rptypes.ProposalState, len(proposalIds))
for bsi := 0; bsi < len(proposalIds); bsi += ProposalStatesBatchSize {
// Get batch start & end index
psi := bsi
pei := bsi + ProposalStatesBatchSize
if pei > len(proposalIds) {
pei = len(proposalIds)
}
// Load states
var wg errgroup.Group
for pi := psi; pi < pei; pi++ {
pi := pi
wg.Go(func() error {
proposalState, err := dao.GetProposalState(rp, proposalIds[pi], nil)
if err == nil {
states[pi] = proposalState
}
return err
})
}
if err := wg.Wait(); err != nil {
return []rptypes.ProposalState{}, err
}
}
// Return
return states, nil
}