mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-25 12:57:18 +00:00
525d3b05a6
* Late block reorgs metrics and logs * tests * mixed thresholds * use threshold variables * use infof --------- Co-authored-by: terencechain <terence@prysmaticlabs.com>
193 lines
6.1 KiB
Go
193 lines
6.1 KiB
Go
package doublylinkedtree
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/prysmaticlabs/prysm/v3/config/features"
|
|
"github.com/prysmaticlabs/prysm/v3/config/params"
|
|
"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
|
|
v1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
|
|
"github.com/prysmaticlabs/prysm/v3/time/slots"
|
|
)
|
|
|
|
// orphanLateBlockFirstThreshold is the number of seconds after which we
|
|
// consider a block to be late, and thus a candidate to being reorged.
|
|
const orphanLateBlockFirstThreshold = 4
|
|
|
|
// ProcessAttestationsThreshold is the number of seconds after which we
|
|
// process attestations for the current slot
|
|
const ProcessAttestationsThreshold = 10
|
|
|
|
// applyWeightChanges recomputes the weight of the node passed as an argument and all of its descendants,
|
|
// using the current balance stored in each node.
|
|
func (n *Node) applyWeightChanges(ctx context.Context) error {
|
|
// Recursively calling the children to sum their weights.
|
|
childrenWeight := uint64(0)
|
|
for _, child := range n.children {
|
|
if ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
if err := child.applyWeightChanges(ctx); err != nil {
|
|
return err
|
|
}
|
|
childrenWeight += child.weight
|
|
}
|
|
if n.root == params.BeaconConfig().ZeroHash {
|
|
return nil
|
|
}
|
|
n.weight = n.balance + childrenWeight
|
|
return nil
|
|
}
|
|
|
|
// updateBestDescendant updates the best descendant of this node and its
|
|
// children.
|
|
func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finalizedEpoch, currentEpoch primitives.Epoch) error {
|
|
if ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
if len(n.children) == 0 {
|
|
n.bestDescendant = nil
|
|
return nil
|
|
}
|
|
|
|
var bestChild *Node
|
|
bestWeight := uint64(0)
|
|
hasViableDescendant := false
|
|
for _, child := range n.children {
|
|
if child == nil {
|
|
return errors.Wrap(ErrNilNode, "could not update best descendant")
|
|
}
|
|
if err := child.updateBestDescendant(ctx, justifiedEpoch, finalizedEpoch, currentEpoch); err != nil {
|
|
return err
|
|
}
|
|
childLeadsToViableHead := child.leadsToViableHead(justifiedEpoch, currentEpoch)
|
|
if childLeadsToViableHead && !hasViableDescendant {
|
|
// The child leads to a viable head, but the current
|
|
// parent's best child doesn't.
|
|
bestWeight = child.weight
|
|
bestChild = child
|
|
hasViableDescendant = true
|
|
} else if childLeadsToViableHead {
|
|
// If both are viable, compare their weights.
|
|
if child.weight == bestWeight {
|
|
// Tie-breaker of equal weights by root.
|
|
if bytes.Compare(child.root[:], bestChild.root[:]) > 0 {
|
|
bestChild = child
|
|
}
|
|
} else if child.weight > bestWeight {
|
|
bestChild = child
|
|
bestWeight = child.weight
|
|
}
|
|
}
|
|
}
|
|
if hasViableDescendant {
|
|
if bestChild.bestDescendant == nil {
|
|
n.bestDescendant = bestChild
|
|
} else {
|
|
n.bestDescendant = bestChild.bestDescendant
|
|
}
|
|
} else {
|
|
n.bestDescendant = nil
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// viableForHead returns true if the node is viable to head.
|
|
// Any node with different finalized or justified epoch than
|
|
// the ones in fork choice store should not be viable to head.
|
|
func (n *Node) viableForHead(justifiedEpoch, currentEpoch primitives.Epoch) bool {
|
|
justified := justifiedEpoch == n.justifiedEpoch || justifiedEpoch == 0
|
|
if features.Get().EnableDefensivePull && !justified && justifiedEpoch+1 == currentEpoch {
|
|
if n.unrealizedJustifiedEpoch+1 >= currentEpoch && n.justifiedEpoch+2 >= currentEpoch {
|
|
justified = true
|
|
}
|
|
}
|
|
return justified
|
|
}
|
|
|
|
func (n *Node) leadsToViableHead(justifiedEpoch, currentEpoch primitives.Epoch) bool {
|
|
if n.bestDescendant == nil {
|
|
return n.viableForHead(justifiedEpoch, currentEpoch)
|
|
}
|
|
return n.bestDescendant.viableForHead(justifiedEpoch, currentEpoch)
|
|
}
|
|
|
|
// setNodeAndParentValidated sets the current node and all the ancestors as validated (i.e. non-optimistic).
|
|
func (n *Node) setNodeAndParentValidated(ctx context.Context) error {
|
|
if ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
|
|
if !n.optimistic {
|
|
return nil
|
|
}
|
|
n.optimistic = false
|
|
|
|
if n.parent == nil {
|
|
return nil
|
|
}
|
|
return n.parent.setNodeAndParentValidated(ctx)
|
|
}
|
|
|
|
// arrivedEarly returns whether this node was inserted before the first
|
|
// threshold to orphan a block.
|
|
// Note that genesisTime has seconds granularity, therefore we use a strict
|
|
// inequality < here. For example a block that arrives 3.9999 seconds into the
|
|
// slot will have secs = 3 below.
|
|
func (n *Node) arrivedEarly(genesisTime uint64) (bool, error) {
|
|
secs, err := slots.SecondsSinceSlotStart(n.slot, genesisTime, n.timestamp)
|
|
return secs < orphanLateBlockFirstThreshold, err
|
|
}
|
|
|
|
// arrivedAfterOrphanCheck returns whether this block was inserted after the
|
|
// intermediate checkpoint to check for candidate of being orphaned.
|
|
// Note that genesisTime has seconds granularity, therefore we use an
|
|
// inequality >= here. For example a block that arrives 10.00001 seconds into the
|
|
// slot will have secs = 10 below.
|
|
func (n *Node) arrivedAfterOrphanCheck(genesisTime uint64) (bool, error) {
|
|
secs, err := slots.SecondsSinceSlotStart(n.slot, genesisTime, n.timestamp)
|
|
return secs >= ProcessAttestationsThreshold, err
|
|
}
|
|
|
|
// nodeTreeDump appends to the given list all the nodes descending from this one
|
|
func (n *Node) nodeTreeDump(ctx context.Context, nodes []*v1.ForkChoiceNode) ([]*v1.ForkChoiceNode, error) {
|
|
if ctx.Err() != nil {
|
|
return nil, ctx.Err()
|
|
}
|
|
var parentRoot [32]byte
|
|
if n.parent != nil {
|
|
parentRoot = n.parent.root
|
|
}
|
|
thisNode := &v1.ForkChoiceNode{
|
|
Slot: n.slot,
|
|
BlockRoot: n.root[:],
|
|
ParentRoot: parentRoot[:],
|
|
JustifiedEpoch: n.justifiedEpoch,
|
|
FinalizedEpoch: n.finalizedEpoch,
|
|
UnrealizedJustifiedEpoch: n.unrealizedJustifiedEpoch,
|
|
UnrealizedFinalizedEpoch: n.unrealizedFinalizedEpoch,
|
|
Balance: n.balance,
|
|
Weight: n.weight,
|
|
ExecutionOptimistic: n.optimistic,
|
|
ExecutionBlockHash: n.payloadHash[:],
|
|
Timestamp: n.timestamp,
|
|
}
|
|
if n.optimistic {
|
|
thisNode.Validity = v1.ForkChoiceNodeValidity_OPTIMISTIC
|
|
} else {
|
|
thisNode.Validity = v1.ForkChoiceNodeValidity_VALID
|
|
}
|
|
|
|
nodes = append(nodes, thisNode)
|
|
var err error
|
|
for _, child := range n.children {
|
|
nodes, err = child.nodeTreeDump(ctx, nodes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return nodes, nil
|
|
}
|