mirror of
https://github.com/OffchainLabs/prysm.git
synced 2026-01-09 15:37:56 -05:00
c96d188468
This pr implements the Gloas builder registry and related beacon state fields per the spec, including proto/SSZ updates and state-native wiring for builders, payload availability, pending payments/withdrawals, and expected withdrawals. This aligns BeaconState with the Gloas container changes and adds supporting hashing/copy helpers. Spec ref: https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/beacon-chain.md
387 lines
15 KiB
Go
387 lines
15 KiB
Go
package state_native
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"fmt"
|
|
|
|
"github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native/types"
|
|
"github.com/OffchainLabs/prysm/v7/beacon-chain/state/stateutil"
|
|
fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
|
|
"github.com/OffchainLabs/prysm/v7/config/params"
|
|
"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
|
|
"github.com/OffchainLabs/prysm/v7/encoding/ssz"
|
|
"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
|
|
"github.com/OffchainLabs/prysm/v7/runtime/version"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// ComputeFieldRootsWithHasher hashes the provided state and returns its respective field roots.
|
|
func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]byte, error) {
|
|
ctx, span := trace.StartSpan(ctx, "ComputeFieldRootsWithHasher")
|
|
defer span.End()
|
|
if ctx.Err() != nil {
|
|
return nil, ctx.Err()
|
|
}
|
|
|
|
if state == nil {
|
|
return nil, errors.New("nil state")
|
|
}
|
|
var fieldRoots [][]byte
|
|
switch state.version {
|
|
case version.Phase0:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateFieldCount)
|
|
case version.Altair:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateAltairFieldCount)
|
|
case version.Bellatrix:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateBellatrixFieldCount)
|
|
case version.Capella:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateCapellaFieldCount)
|
|
case version.Deneb:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateDenebFieldCount)
|
|
case version.Electra:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateElectraFieldCount)
|
|
case version.Fulu:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateFuluFieldCount)
|
|
case version.Gloas:
|
|
fieldRoots = make([][]byte, params.BeaconConfig().BeaconStateGloasFieldCount)
|
|
default:
|
|
return nil, fmt.Errorf("unknown state version %s", version.String(state.version))
|
|
}
|
|
|
|
// Genesis time root.
|
|
genesisRoot := ssz.Uint64Root(state.genesisTime)
|
|
fieldRoots[types.GenesisTime.RealPosition()] = genesisRoot[:]
|
|
|
|
// Genesis validators root.
|
|
var r [32]byte
|
|
copy(r[:], state.genesisValidatorsRoot[:])
|
|
fieldRoots[types.GenesisValidatorsRoot.RealPosition()] = r[:]
|
|
|
|
// Slot root.
|
|
slotRoot := ssz.Uint64Root(uint64(state.slot))
|
|
fieldRoots[types.Slot.RealPosition()] = slotRoot[:]
|
|
|
|
// Fork data structure root.
|
|
forkHashTreeRoot, err := ssz.ForkRoot(state.fork)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute fork merkleization")
|
|
}
|
|
fieldRoots[types.Fork.RealPosition()] = forkHashTreeRoot[:]
|
|
|
|
// BeaconBlockHeader data structure root.
|
|
headerHashTreeRoot, err := stateutil.BlockHeaderRoot(state.latestBlockHeader)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute block header merkleization")
|
|
}
|
|
fieldRoots[types.LatestBlockHeader.RealPosition()] = headerHashTreeRoot[:]
|
|
|
|
// BlockRoots array root.
|
|
blockRootsRoot, err := stateutil.ArraysRoot(state.blockRootsVal().Slice(), fieldparams.BlockRootsLength)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute block roots merkleization")
|
|
}
|
|
fieldRoots[types.BlockRoots.RealPosition()] = blockRootsRoot[:]
|
|
|
|
// StateRoots array root.
|
|
stateRootsRoot, err := stateutil.ArraysRoot(state.stateRootsVal().Slice(), fieldparams.StateRootsLength)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute state roots merkleization")
|
|
}
|
|
fieldRoots[types.StateRoots.RealPosition()] = stateRootsRoot[:]
|
|
|
|
// HistoricalRoots slice root.
|
|
hRoots := make([][]byte, len(state.historicalRoots))
|
|
for i := range hRoots {
|
|
hRoots[i] = state.historicalRoots[i][:]
|
|
}
|
|
historicalRootsRt, err := ssz.ByteArrayRootWithLimit(hRoots, fieldparams.HistoricalRootsLength)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute historical roots merkleization")
|
|
}
|
|
fieldRoots[types.HistoricalRoots.RealPosition()] = historicalRootsRt[:]
|
|
|
|
// Eth1Data data structure root.
|
|
eth1HashTreeRoot, err := stateutil.Eth1Root(state.eth1Data)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute eth1data merkleization")
|
|
}
|
|
fieldRoots[types.Eth1Data.RealPosition()] = eth1HashTreeRoot[:]
|
|
|
|
// Eth1DataVotes slice root.
|
|
eth1VotesRoot, err := stateutil.Eth1DataVotesRoot(state.eth1DataVotes)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute eth1data votes merkleization")
|
|
}
|
|
fieldRoots[types.Eth1DataVotes.RealPosition()] = eth1VotesRoot[:]
|
|
|
|
// Eth1DepositIndex root.
|
|
eth1DepositIndexBuf := make([]byte, 8)
|
|
binary.LittleEndian.PutUint64(eth1DepositIndexBuf, state.eth1DepositIndex)
|
|
eth1DepositBuf := bytesutil.ToBytes32(eth1DepositIndexBuf)
|
|
fieldRoots[types.Eth1DepositIndex.RealPosition()] = eth1DepositBuf[:]
|
|
|
|
// Validators slice root.
|
|
validatorsRoot, err := stateutil.ValidatorRegistryRoot(state.validatorsVal())
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute validator registry merkleization")
|
|
}
|
|
fieldRoots[types.Validators.RealPosition()] = validatorsRoot[:]
|
|
|
|
// Balances slice root.
|
|
balancesRoot, err := stateutil.Uint64ListRootWithRegistryLimit(state.balancesVal())
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute validator balances merkleization")
|
|
}
|
|
fieldRoots[types.Balances.RealPosition()] = balancesRoot[:]
|
|
|
|
// RandaoMixes array root.
|
|
randaoRootsRoot, err := stateutil.ArraysRoot(state.randaoMixesVal().Slice(), fieldparams.RandaoMixesLength)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute randao roots merkleization")
|
|
}
|
|
fieldRoots[types.RandaoMixes.RealPosition()] = randaoRootsRoot[:]
|
|
|
|
// Slashings array root.
|
|
slashingsRootsRoot, err := ssz.SlashingsRoot(state.slashings)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute slashings merkleization")
|
|
}
|
|
fieldRoots[types.Slashings.RealPosition()] = slashingsRootsRoot[:]
|
|
|
|
if state.version == version.Phase0 {
|
|
// PreviousEpochAttestations slice root.
|
|
prevAttsRoot, err := stateutil.EpochAttestationsRoot(state.previousEpochAttestations)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute previous epoch attestations merkleization")
|
|
}
|
|
fieldRoots[types.PreviousEpochAttestations.RealPosition()] = prevAttsRoot[:]
|
|
|
|
// CurrentEpochAttestations slice root.
|
|
currAttsRoot, err := stateutil.EpochAttestationsRoot(state.currentEpochAttestations)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute current epoch attestations merkleization")
|
|
}
|
|
fieldRoots[types.CurrentEpochAttestations.RealPosition()] = currAttsRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Altair {
|
|
// PreviousEpochParticipation slice root.
|
|
prevParticipationRoot, err := stateutil.ParticipationBitsRoot(state.previousEpochParticipation)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute previous epoch participation merkleization")
|
|
}
|
|
fieldRoots[types.PreviousEpochParticipationBits.RealPosition()] = prevParticipationRoot[:]
|
|
|
|
// CurrentEpochParticipation slice root.
|
|
currParticipationRoot, err := stateutil.ParticipationBitsRoot(state.currentEpochParticipation)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute current epoch participation merkleization")
|
|
}
|
|
fieldRoots[types.CurrentEpochParticipationBits.RealPosition()] = currParticipationRoot[:]
|
|
}
|
|
|
|
// JustificationBits root.
|
|
justifiedBitsRoot := bytesutil.ToBytes32(state.justificationBits)
|
|
fieldRoots[types.JustificationBits.RealPosition()] = justifiedBitsRoot[:]
|
|
|
|
// PreviousJustifiedCheckpoint data structure root.
|
|
prevCheckRoot, err := ssz.CheckpointRoot(state.previousJustifiedCheckpoint)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute previous justified checkpoint merkleization")
|
|
}
|
|
fieldRoots[types.PreviousJustifiedCheckpoint.RealPosition()] = prevCheckRoot[:]
|
|
|
|
// CurrentJustifiedCheckpoint data structure root.
|
|
currJustRoot, err := ssz.CheckpointRoot(state.currentJustifiedCheckpoint)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute current justified checkpoint merkleization")
|
|
}
|
|
fieldRoots[types.CurrentJustifiedCheckpoint.RealPosition()] = currJustRoot[:]
|
|
|
|
// FinalizedCheckpoint data structure root.
|
|
finalRoot, err := ssz.CheckpointRoot(state.finalizedCheckpoint)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute finalized checkpoint merkleization")
|
|
}
|
|
fieldRoots[types.FinalizedCheckpoint.RealPosition()] = finalRoot[:]
|
|
|
|
if state.version >= version.Altair {
|
|
// Inactivity scores root.
|
|
inactivityScoresRoot, err := stateutil.Uint64ListRootWithRegistryLimit(state.inactivityScoresVal())
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute inactivityScoreRoot")
|
|
}
|
|
fieldRoots[types.InactivityScores.RealPosition()] = inactivityScoresRoot[:]
|
|
|
|
// Current sync committee root.
|
|
currentSyncCommitteeRoot, err := stateutil.SyncCommitteeRoot(state.currentSyncCommittee)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute sync committee merkleization")
|
|
}
|
|
fieldRoots[types.CurrentSyncCommittee.RealPosition()] = currentSyncCommitteeRoot[:]
|
|
|
|
// Next sync committee root.
|
|
nextSyncCommitteeRoot, err := stateutil.SyncCommitteeRoot(state.nextSyncCommittee)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute sync committee merkleization")
|
|
}
|
|
fieldRoots[types.NextSyncCommittee.RealPosition()] = nextSyncCommitteeRoot[:]
|
|
}
|
|
|
|
if state.version == version.Bellatrix {
|
|
// Execution payload root.
|
|
executionPayloadRoot, err := state.latestExecutionPayloadHeader.HashTreeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fieldRoots[types.LatestExecutionPayloadHeader.RealPosition()] = executionPayloadRoot[:]
|
|
}
|
|
|
|
if state.version == version.Capella {
|
|
// Execution payload root.
|
|
executionPayloadRoot, err := state.latestExecutionPayloadHeaderCapella.HashTreeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fieldRoots[types.LatestExecutionPayloadHeaderCapella.RealPosition()] = executionPayloadRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Deneb && state.version < version.Gloas {
|
|
// Execution payload root.
|
|
executionPayloadRoot, err := state.latestExecutionPayloadHeaderDeneb.HashTreeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fieldRoots[types.LatestExecutionPayloadHeaderDeneb.RealPosition()] = executionPayloadRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Gloas {
|
|
// Execution payload bid root for Gloas.
|
|
bidRoot, err := state.latestExecutionPayloadBid.HashTreeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fieldRoots[types.LatestExecutionPayloadBid.RealPosition()] = bidRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Capella {
|
|
// Next withdrawal index root.
|
|
nextWithdrawalIndexRoot := make([]byte, 32)
|
|
binary.LittleEndian.PutUint64(nextWithdrawalIndexRoot, state.nextWithdrawalIndex)
|
|
fieldRoots[types.NextWithdrawalIndex.RealPosition()] = nextWithdrawalIndexRoot
|
|
|
|
// Next partial withdrawal validator index root.
|
|
nextWithdrawalValidatorIndexRoot := make([]byte, 32)
|
|
binary.LittleEndian.PutUint64(nextWithdrawalValidatorIndexRoot, uint64(state.nextWithdrawalValidatorIndex))
|
|
fieldRoots[types.NextWithdrawalValidatorIndex.RealPosition()] = nextWithdrawalValidatorIndexRoot
|
|
|
|
// Historical summary root.
|
|
historicalSummaryRoot, err := stateutil.HistoricalSummariesRoot(state.historicalSummaries)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute historical summary merkleization")
|
|
}
|
|
fieldRoots[types.HistoricalSummaries.RealPosition()] = historicalSummaryRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Electra {
|
|
// DepositRequestsStartIndex root.
|
|
drsiRoot := ssz.Uint64Root(state.depositRequestsStartIndex)
|
|
fieldRoots[types.DepositRequestsStartIndex.RealPosition()] = drsiRoot[:]
|
|
|
|
// DepositBalanceToConsume root.
|
|
dbtcRoot := ssz.Uint64Root(uint64(state.depositBalanceToConsume))
|
|
fieldRoots[types.DepositBalanceToConsume.RealPosition()] = dbtcRoot[:]
|
|
|
|
// ExitBalanceToConsume root.
|
|
ebtcRoot := ssz.Uint64Root(uint64(state.exitBalanceToConsume))
|
|
fieldRoots[types.ExitBalanceToConsume.RealPosition()] = ebtcRoot[:]
|
|
|
|
// EarliestExitEpoch root.
|
|
eeeRoot := ssz.Uint64Root(uint64(state.earliestExitEpoch))
|
|
fieldRoots[types.EarliestExitEpoch.RealPosition()] = eeeRoot[:]
|
|
|
|
// ConsolidationBalanceToConsume root.
|
|
cbtcRoot := ssz.Uint64Root(uint64(state.consolidationBalanceToConsume))
|
|
fieldRoots[types.ConsolidationBalanceToConsume.RealPosition()] = cbtcRoot[:]
|
|
|
|
// EarliestConsolidationEpoch root.
|
|
eceRoot := ssz.Uint64Root(uint64(state.earliestConsolidationEpoch))
|
|
fieldRoots[types.EarliestConsolidationEpoch.RealPosition()] = eceRoot[:]
|
|
|
|
// PendingDeposits root.
|
|
pbdRoot, err := stateutil.PendingDepositsRoot(state.pendingDeposits)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute pending balance deposits merkleization")
|
|
}
|
|
fieldRoots[types.PendingDeposits.RealPosition()] = pbdRoot[:]
|
|
|
|
// PendingPartialWithdrawals root.
|
|
ppwRoot, err := stateutil.PendingPartialWithdrawalsRoot(state.pendingPartialWithdrawals)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute pending partial withdrawals merkleization")
|
|
}
|
|
fieldRoots[types.PendingPartialWithdrawals.RealPosition()] = ppwRoot[:]
|
|
|
|
// PendingConsolidations root.
|
|
pcRoot, err := stateutil.PendingConsolidationsRoot(state.pendingConsolidations)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute pending consolidations merkleization")
|
|
}
|
|
fieldRoots[types.PendingConsolidations.RealPosition()] = pcRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Fulu {
|
|
// Proposer lookahead root.
|
|
proposerLookaheadRoot, err := stateutil.ProposerLookaheadRoot(state.proposerLookahead)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute proposer lookahead merkleization")
|
|
}
|
|
fieldRoots[types.ProposerLookahead.RealPosition()] = proposerLookaheadRoot[:]
|
|
}
|
|
|
|
if state.version >= version.Gloas {
|
|
buildersRoot, err := stateutil.BuildersRoot(state.builders)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute builders merkleization")
|
|
}
|
|
fieldRoots[types.Builders.RealPosition()] = buildersRoot[:]
|
|
|
|
nextWithdrawalBuilderIndexRoot := ssz.Uint64Root(uint64(state.nextWithdrawalBuilderIndex))
|
|
fieldRoots[types.NextWithdrawalBuilderIndex.RealPosition()] = nextWithdrawalBuilderIndexRoot[:]
|
|
|
|
epaRoot, err := stateutil.ExecutionPayloadAvailabilityRoot(state.executionPayloadAvailability)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute execution payload availability merkleization")
|
|
}
|
|
|
|
fieldRoots[types.ExecutionPayloadAvailability.RealPosition()] = epaRoot[:]
|
|
|
|
bppRoot, err := stateutil.BuilderPendingPaymentsRoot(state.builderPendingPayments)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute builder pending payments merkleization")
|
|
}
|
|
|
|
fieldRoots[types.BuilderPendingPayments.RealPosition()] = bppRoot[:]
|
|
|
|
bpwRoot, err := stateutil.BuilderPendingWithdrawalsRoot(state.builderPendingWithdrawals)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute builder pending withdrawals merkleization")
|
|
}
|
|
|
|
fieldRoots[types.BuilderPendingWithdrawals.RealPosition()] = bpwRoot[:]
|
|
|
|
lbhRoot := bytesutil.ToBytes32(state.latestBlockHash)
|
|
fieldRoots[types.LatestBlockHash.RealPosition()] = lbhRoot[:]
|
|
|
|
expectedWithdrawalsRoot, err := ssz.WithdrawalSliceRoot(state.payloadExpectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not compute payload expected withdrawals root")
|
|
}
|
|
|
|
fieldRoots[types.PayloadExpectedWithdrawals.RealPosition()] = expectedWithdrawalsRoot[:]
|
|
}
|
|
return fieldRoots, nil
|
|
}
|