forked from prysmaticlabs/prysm
/
status.go
216 lines (192 loc) · 7.27 KB
/
status.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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
package validator
import (
"context"
"errors"
"math/big"
"time"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/traceutil"
"go.opencensus.io/trace"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
var errPubkeyDoesNotExist = errors.New("pubkey does not exist")
// ValidatorStatus returns the validator status of the current epoch.
// The status response can be one of the following:
// DEPOSITED - validator's deposit has been recognized by Ethereum 1, not yet recognized by Ethereum 2.
// PENDING - validator is in Ethereum 2's activation queue.
// ACTIVE - validator is active.
// EXITING - validator has initiated an an exit request, or has dropped below the ejection balance and is being kicked out.
// EXITED - validator is no longer validating.
// SLASHING - validator has been kicked out due to meeting a slashing condition.
// UNKNOWN_STATUS - validator does not have a known status in the network.
func (vs *Server) ValidatorStatus(
ctx context.Context,
req *ethpb.ValidatorStatusRequest) (*ethpb.ValidatorStatusResponse, error) {
headState, err := vs.HeadFetcher.HeadState(ctx)
if err != nil {
return nil, status.Error(codes.Internal, "Could not get head state")
}
return vs.validatorStatus(ctx, req.PublicKey, headState), nil
}
// multipleValidatorStatus returns the validator status response for the set of validators
// requested by their pub keys.
func (vs *Server) multipleValidatorStatus(
ctx context.Context,
pubkeys [][]byte,
) (bool, []*ethpb.ValidatorActivationResponse_Status, error) {
headState, err := vs.HeadFetcher.HeadState(ctx)
if err != nil {
return false, nil, err
}
activeValidatorExists := false
statusResponses := make([]*ethpb.ValidatorActivationResponse_Status, len(pubkeys))
for i, key := range pubkeys {
if ctx.Err() != nil {
return false, nil, ctx.Err()
}
status := vs.validatorStatus(ctx, key, headState)
if status == nil {
continue
}
resp := ðpb.ValidatorActivationResponse_Status{
Status: status,
PublicKey: key,
}
statusResponses[i] = resp
if status.Status == ethpb.ValidatorStatus_ACTIVE {
activeValidatorExists = true
}
}
return activeValidatorExists, statusResponses, nil
}
func (vs *Server) validatorStatus(ctx context.Context, pubKey []byte, headState *stateTrie.BeaconState) *ethpb.ValidatorStatusResponse {
ctx, span := trace.StartSpan(ctx, "validatorServer.validatorStatus")
defer span.End()
resp := ðpb.ValidatorStatusResponse{
Status: ethpb.ValidatorStatus_UNKNOWN_STATUS,
ActivationEpoch: int64(params.BeaconConfig().FarFutureEpoch),
}
vStatus, idx, err := vs.retrieveStatusFromState(ctx, pubKey, headState)
if err != nil && err != errPubkeyDoesNotExist {
traceutil.AnnotateError(span, err)
return resp
}
resp.Status = vStatus
if err != errPubkeyDoesNotExist {
val, err := headState.ValidatorAtIndex(idx)
if err != nil {
traceutil.AnnotateError(span, err)
return resp
}
resp.ActivationEpoch = int64(val.ActivationEpoch)
}
// If no connection to ETH1, the deposit block number or position in queue cannot be determined.
if !vs.Eth1InfoFetcher.IsConnectedToETH1() {
log.Warn("Not connected to ETH1. Cannot determine validator ETH1 deposit block number")
return resp
}
_, eth1BlockNumBigInt := vs.DepositFetcher.DepositByPubkey(ctx, pubKey)
if eth1BlockNumBigInt == nil { // No deposit found in ETH1.
return resp
}
if resp.Status == ethpb.ValidatorStatus_UNKNOWN_STATUS {
resp.Status = ethpb.ValidatorStatus_DEPOSITED
}
resp.Eth1DepositBlockNumber = eth1BlockNumBigInt.Uint64()
depositBlockSlot, err := vs.depositBlockSlot(ctx, eth1BlockNumBigInt, headState)
if err != nil {
return resp
}
resp.DepositInclusionSlot = int64(depositBlockSlot)
// If validator has been activated at any point, they are not in the queue so we can return
// the request early. Also if the validator has exited,slashed or initiated its exit
// we return the request early too. We only proceed if its status is pending active
// Additionally, if idx is zero (default return value) then we know this
// validator cannot be in the queue either.
if resp.Status != ethpb.ValidatorStatus_PENDING || idx == 0 {
return resp
}
var lastActivatedValidatorIdx uint64
for j := headState.NumValidators() - 1; j >= 0; j-- {
val, err := headState.ValidatorAtIndex(uint64(j))
if err != nil {
return resp
}
if helpers.IsActiveValidator(val, helpers.CurrentEpoch(headState)) {
lastActivatedValidatorIdx = uint64(j)
break
}
}
// Our position in the activation queue is the above index - our validator index.
if lastActivatedValidatorIdx < idx {
resp.PositionInActivationQueue = int64(idx - lastActivatedValidatorIdx)
}
return resp
}
func (vs *Server) retrieveStatusFromState(
ctx context.Context,
pubKey []byte,
headState *stateTrie.BeaconState,
) (ethpb.ValidatorStatus, uint64, error) {
if headState == nil {
return ethpb.ValidatorStatus_UNKNOWN_STATUS, 0, errors.New("head state does not exist")
}
idx, ok, err := vs.BeaconDB.ValidatorIndex(ctx, pubKey)
if err != nil {
return ethpb.ValidatorStatus_UNKNOWN_STATUS, 0, err
}
if !ok || int(idx) >= headState.NumValidators() {
return ethpb.ValidatorStatus_UNKNOWN_STATUS, 0, errPubkeyDoesNotExist
}
return vs.assignmentStatus(idx, headState), idx, nil
}
func (vs *Server) assignmentStatus(validatorIdx uint64, beaconState *stateTrie.BeaconState) ethpb.ValidatorStatus {
validator, err := beaconState.ValidatorAtIndex(validatorIdx)
if err != nil {
return ethpb.ValidatorStatus_UNKNOWN_STATUS
}
currentEpoch := helpers.CurrentEpoch(beaconState)
farFutureEpoch := params.BeaconConfig().FarFutureEpoch
if validator == nil {
return ethpb.ValidatorStatus_UNKNOWN_STATUS
}
if currentEpoch < validator.ActivationEligibilityEpoch {
return ethpb.ValidatorStatus_DEPOSITED
}
if currentEpoch < validator.ActivationEpoch {
return ethpb.ValidatorStatus_PENDING
}
if validator.ExitEpoch == farFutureEpoch {
return ethpb.ValidatorStatus_ACTIVE
}
if currentEpoch < validator.ExitEpoch {
if validator.Slashed {
return ethpb.ValidatorStatus_SLASHING
}
return ethpb.ValidatorStatus_EXITING
}
return ethpb.ValidatorStatus_EXITED
}
func (vs *Server) depositBlockSlot(ctx context.Context, eth1BlockNumBigInt *big.Int, beaconState *stateTrie.BeaconState) (uint64, error) {
var depositBlockSlot uint64
blockTimeStamp, err := vs.BlockFetcher.BlockTimeByHeight(ctx, eth1BlockNumBigInt)
if err != nil {
return 0, err
}
followTime := time.Duration(params.BeaconConfig().Eth1FollowDistance*params.BeaconConfig().GoerliBlockTime) * time.Second
eth1UnixTime := time.Unix(int64(blockTimeStamp), 0).Add(followTime)
votingPeriod := time.Duration(params.BeaconConfig().SlotsPerEth1VotingPeriod*params.BeaconConfig().SecondsPerSlot) * time.Second
timeToInclusion := eth1UnixTime.Add(votingPeriod)
eth2Genesis := time.Unix(int64(beaconState.GenesisTime()), 0)
if eth2Genesis.After(timeToInclusion) {
depositBlockSlot = 0
} else {
eth2TimeDifference := timeToInclusion.Sub(eth2Genesis).Seconds()
depositBlockSlot = uint64(eth2TimeDifference) / params.BeaconConfig().SecondsPerSlot
}
return depositBlockSlot, nil
}