mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-25 04:47:18 +00:00
cb02a6897d
* proto+ssz * refactor GetBlindedBlockSSZ (cherry picked from commit 97483c339f99b0d96bd81846a979383ffd2b0cda) # Conflicts: # beacon-chain/rpc/eth/beacon/blocks.go (cherry picked from commit 9e4e82d2c55e09be7568b28eaa33cdd1141445f4) # Conflicts: # beacon-chain/rpc/eth/beacon/blocks.go * add Capella version (cherry picked from commit 5d6fd0bbe663e5dd16df5b2e773f68982bbcd24e) (cherry picked from commit 82f6ddb693ac9e8b4336b30fae724e478b9e8ec0) * support SSZ lol (cherry picked from commit 52bc2c8d617ac3e1254c493fa053cdce4a1ebd63) (cherry picked from commit d7d70bc25b3ee8acbea10aaf77d26cd1f8c5f26f) * update withdrawals proto * refactor and test GetBlockV2 (cherry picked from commit c1d4eaa79d4df04bd284ec65cf261b6f5f260a97) # Conflicts: # beacon-chain/rpc/eth/beacon/blocks.go * refactor and test GetSSZBlockV2 (cherry picked from commit fbc4e73d31c2f68d55d1e2bb8e7f2d8c7458c0a0) # Conflicts: # beacon-chain/rpc/eth/beacon/blocks.go * test other functions (cherry picked from commit 31d4a4cd1165b882d823696e5983ac6635262ec2) * move stuff to blinded_blocks.go (cherry picked from commit 0a9e1658ddb28f45ae5c1cb9fc2703cbb8c6708d) # Conflicts: # beacon-chain/rpc/eth/beacon/blocks.go * fix migration code * add Capella to SubmitBlock * custom hooks * missing structs * fix tests * fix tests * review * fix build issues * replace ioutil with io Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
1100 lines
36 KiB
Go
1100 lines
36 KiB
Go
package util
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
|
|
"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/signing"
|
|
"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/time"
|
|
"github.com/prysmaticlabs/prysm/v3/beacon-chain/db/iface"
|
|
"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
|
|
fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
|
|
"github.com/prysmaticlabs/prysm/v3/config/params"
|
|
"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
|
|
"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
|
|
types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
|
|
"github.com/prysmaticlabs/prysm/v3/crypto/bls"
|
|
"github.com/prysmaticlabs/prysm/v3/crypto/rand"
|
|
"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
|
|
enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
|
|
v1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
|
|
v2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
|
|
ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
|
|
"github.com/prysmaticlabs/prysm/v3/testing/assertions"
|
|
"github.com/prysmaticlabs/prysm/v3/testing/require"
|
|
)
|
|
|
|
// BlockGenConfig is used to define the requested conditions
|
|
// for block generation.
|
|
type BlockGenConfig struct {
|
|
NumProposerSlashings uint64
|
|
NumAttesterSlashings uint64
|
|
NumAttestations uint64
|
|
NumDeposits uint64
|
|
NumVoluntaryExits uint64
|
|
NumTransactions uint64 // Only for post Bellatrix blocks
|
|
FullSyncAggregate bool
|
|
}
|
|
|
|
// DefaultBlockGenConfig returns the block config that utilizes the
|
|
// current params in the beacon config.
|
|
func DefaultBlockGenConfig() *BlockGenConfig {
|
|
return &BlockGenConfig{
|
|
NumProposerSlashings: 0,
|
|
NumAttesterSlashings: 0,
|
|
NumAttestations: 1,
|
|
NumDeposits: 0,
|
|
NumVoluntaryExits: 0,
|
|
NumTransactions: 0,
|
|
}
|
|
}
|
|
|
|
// NewBeaconBlock creates a beacon block with minimum marshalable fields.
|
|
func NewBeaconBlock() *ethpb.SignedBeaconBlock {
|
|
return ðpb.SignedBeaconBlock{
|
|
Block: ðpb.BeaconBlock{
|
|
ParentRoot: make([]byte, fieldparams.RootLength),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
Body: ðpb.BeaconBlockBody{
|
|
RandaoReveal: make([]byte, fieldparams.BLSSignatureLength),
|
|
Eth1Data: ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
},
|
|
Graffiti: make([]byte, fieldparams.RootLength),
|
|
Attestations: []*ethpb.Attestation{},
|
|
AttesterSlashings: []*ethpb.AttesterSlashing{},
|
|
Deposits: []*ethpb.Deposit{},
|
|
ProposerSlashings: []*ethpb.ProposerSlashing{},
|
|
VoluntaryExits: []*ethpb.SignedVoluntaryExit{},
|
|
},
|
|
},
|
|
Signature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
|
|
// GenerateFullBlock generates a fully valid block with the requested parameters.
|
|
// Use BlockGenConfig to declare the conditions you would like the block generated under.
|
|
func GenerateFullBlock(
|
|
bState state.BeaconState,
|
|
privs []bls.SecretKey,
|
|
conf *BlockGenConfig,
|
|
slot types.Slot,
|
|
) (*ethpb.SignedBeaconBlock, error) {
|
|
ctx := context.Background()
|
|
currentSlot := bState.Slot()
|
|
if currentSlot > slot {
|
|
return nil, fmt.Errorf("current slot in state is larger than given slot. %d > %d", currentSlot, slot)
|
|
}
|
|
bState = bState.Copy()
|
|
|
|
if conf == nil {
|
|
conf = &BlockGenConfig{}
|
|
}
|
|
|
|
var err error
|
|
var pSlashings []*ethpb.ProposerSlashing
|
|
numToGen := conf.NumProposerSlashings
|
|
if numToGen > 0 {
|
|
pSlashings, err = generateProposerSlashings(bState, privs, numToGen)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "failed generating %d proposer slashings:", numToGen)
|
|
}
|
|
}
|
|
|
|
numToGen = conf.NumAttesterSlashings
|
|
var aSlashings []*ethpb.AttesterSlashing
|
|
if numToGen > 0 {
|
|
aSlashings, err = generateAttesterSlashings(bState, privs, numToGen)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "failed generating %d attester slashings:", numToGen)
|
|
}
|
|
}
|
|
|
|
numToGen = conf.NumAttestations
|
|
var atts []*ethpb.Attestation
|
|
if numToGen > 0 {
|
|
atts, err = GenerateAttestations(bState, privs, numToGen, slot, false)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "failed generating %d attestations:", numToGen)
|
|
}
|
|
}
|
|
|
|
numToGen = conf.NumDeposits
|
|
var newDeposits []*ethpb.Deposit
|
|
eth1Data := bState.Eth1Data()
|
|
if numToGen > 0 {
|
|
newDeposits, eth1Data, err = generateDepositsAndEth1Data(bState, numToGen)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "failed generating %d deposits:", numToGen)
|
|
}
|
|
}
|
|
|
|
numToGen = conf.NumVoluntaryExits
|
|
var exits []*ethpb.SignedVoluntaryExit
|
|
if numToGen > 0 {
|
|
exits, err = generateVoluntaryExits(bState, privs, numToGen)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "failed generating %d voluntary exits:", numToGen)
|
|
}
|
|
}
|
|
|
|
newHeader := bState.LatestBlockHeader()
|
|
prevStateRoot, err := bState.HashTreeRoot(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
newHeader.StateRoot = prevStateRoot[:]
|
|
parentRoot, err := newHeader.HashTreeRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if slot == currentSlot {
|
|
slot = currentSlot + 1
|
|
}
|
|
|
|
// Temporarily incrementing the beacon state slot here since BeaconProposerIndex is a
|
|
// function deterministic on beacon state slot.
|
|
if err := bState.SetSlot(slot); err != nil {
|
|
return nil, err
|
|
}
|
|
reveal, err := RandaoReveal(bState, time.CurrentEpoch(bState), privs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
idx, err := helpers.BeaconProposerIndex(ctx, bState)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
block := ðpb.BeaconBlock{
|
|
Slot: slot,
|
|
ParentRoot: parentRoot[:],
|
|
ProposerIndex: idx,
|
|
Body: ðpb.BeaconBlockBody{
|
|
Eth1Data: eth1Data,
|
|
RandaoReveal: reveal,
|
|
ProposerSlashings: pSlashings,
|
|
AttesterSlashings: aSlashings,
|
|
Attestations: atts,
|
|
VoluntaryExits: exits,
|
|
Deposits: newDeposits,
|
|
Graffiti: make([]byte, fieldparams.RootLength),
|
|
},
|
|
}
|
|
if err := bState.SetSlot(currentSlot); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
signature, err := BlockSignature(bState, block, privs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ðpb.SignedBeaconBlock{Block: block, Signature: signature.Marshal()}, nil
|
|
}
|
|
|
|
// GenerateProposerSlashingForValidator for a specific validator index.
|
|
func GenerateProposerSlashingForValidator(
|
|
bState state.BeaconState,
|
|
priv bls.SecretKey,
|
|
idx types.ValidatorIndex,
|
|
) (*ethpb.ProposerSlashing, error) {
|
|
header1 := HydrateSignedBeaconHeader(ðpb.SignedBeaconBlockHeader{
|
|
Header: ðpb.BeaconBlockHeader{
|
|
ProposerIndex: idx,
|
|
Slot: bState.Slot(),
|
|
BodyRoot: bytesutil.PadTo([]byte{0, 1, 0}, fieldparams.RootLength),
|
|
},
|
|
})
|
|
currentEpoch := time.CurrentEpoch(bState)
|
|
var err error
|
|
header1.Signature, err = signing.ComputeDomainAndSign(bState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, priv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
header2 := ðpb.SignedBeaconBlockHeader{
|
|
Header: ðpb.BeaconBlockHeader{
|
|
ProposerIndex: idx,
|
|
Slot: bState.Slot(),
|
|
BodyRoot: bytesutil.PadTo([]byte{0, 2, 0}, fieldparams.RootLength),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ParentRoot: make([]byte, fieldparams.RootLength),
|
|
},
|
|
}
|
|
header2.Signature, err = signing.ComputeDomainAndSign(bState, currentEpoch, header2.Header, params.BeaconConfig().DomainBeaconProposer, priv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ðpb.ProposerSlashing{
|
|
Header_1: header1,
|
|
Header_2: header2,
|
|
}, nil
|
|
}
|
|
|
|
func generateProposerSlashings(
|
|
bState state.BeaconState,
|
|
privs []bls.SecretKey,
|
|
numSlashings uint64,
|
|
) ([]*ethpb.ProposerSlashing, error) {
|
|
proposerSlashings := make([]*ethpb.ProposerSlashing, numSlashings)
|
|
for i := uint64(0); i < numSlashings; i++ {
|
|
proposerIndex, err := randValIndex(bState)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
slashing, err := GenerateProposerSlashingForValidator(bState, privs[proposerIndex], proposerIndex)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
proposerSlashings[i] = slashing
|
|
}
|
|
return proposerSlashings, nil
|
|
}
|
|
|
|
// GenerateAttesterSlashingForValidator for a specific validator index.
|
|
func GenerateAttesterSlashingForValidator(
|
|
bState state.BeaconState,
|
|
priv bls.SecretKey,
|
|
idx types.ValidatorIndex,
|
|
) (*ethpb.AttesterSlashing, error) {
|
|
currentEpoch := time.CurrentEpoch(bState)
|
|
|
|
att1 := ðpb.IndexedAttestation{
|
|
Data: ðpb.AttestationData{
|
|
Slot: bState.Slot(),
|
|
CommitteeIndex: 0,
|
|
BeaconBlockRoot: make([]byte, fieldparams.RootLength),
|
|
Target: ðpb.Checkpoint{
|
|
Epoch: currentEpoch,
|
|
Root: params.BeaconConfig().ZeroHash[:],
|
|
},
|
|
Source: ðpb.Checkpoint{
|
|
Epoch: currentEpoch + 1,
|
|
Root: params.BeaconConfig().ZeroHash[:],
|
|
},
|
|
},
|
|
AttestingIndices: []uint64{uint64(idx)},
|
|
}
|
|
var err error
|
|
att1.Signature, err = signing.ComputeDomainAndSign(bState, currentEpoch, att1.Data, params.BeaconConfig().DomainBeaconAttester, priv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
att2 := ðpb.IndexedAttestation{
|
|
Data: ðpb.AttestationData{
|
|
Slot: bState.Slot(),
|
|
CommitteeIndex: 0,
|
|
BeaconBlockRoot: make([]byte, fieldparams.RootLength),
|
|
Target: ðpb.Checkpoint{
|
|
Epoch: currentEpoch,
|
|
Root: params.BeaconConfig().ZeroHash[:],
|
|
},
|
|
Source: ðpb.Checkpoint{
|
|
Epoch: currentEpoch,
|
|
Root: params.BeaconConfig().ZeroHash[:],
|
|
},
|
|
},
|
|
AttestingIndices: []uint64{uint64(idx)},
|
|
}
|
|
att2.Signature, err = signing.ComputeDomainAndSign(bState, currentEpoch, att2.Data, params.BeaconConfig().DomainBeaconAttester, priv)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ðpb.AttesterSlashing{
|
|
Attestation_1: att1,
|
|
Attestation_2: att2,
|
|
}, nil
|
|
}
|
|
|
|
func generateAttesterSlashings(
|
|
bState state.BeaconState,
|
|
privs []bls.SecretKey,
|
|
numSlashings uint64,
|
|
) ([]*ethpb.AttesterSlashing, error) {
|
|
attesterSlashings := make([]*ethpb.AttesterSlashing, numSlashings)
|
|
randGen := rand.NewDeterministicGenerator()
|
|
for i := uint64(0); i < numSlashings; i++ {
|
|
committeeIndex := randGen.Uint64() % helpers.SlotCommitteeCount(uint64(bState.NumValidators()))
|
|
committee, err := helpers.BeaconCommitteeFromState(context.Background(), bState, bState.Slot(), types.CommitteeIndex(committeeIndex))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
randIndex := randGen.Uint64() % uint64(len(committee))
|
|
valIndex := committee[randIndex]
|
|
slashing, err := GenerateAttesterSlashingForValidator(bState, privs[valIndex], valIndex)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
attesterSlashings[i] = slashing
|
|
}
|
|
return attesterSlashings, nil
|
|
}
|
|
|
|
func generateDepositsAndEth1Data(
|
|
bState state.BeaconState,
|
|
numDeposits uint64,
|
|
) (
|
|
[]*ethpb.Deposit,
|
|
*ethpb.Eth1Data,
|
|
error,
|
|
) {
|
|
previousDepsLen := bState.Eth1DepositIndex()
|
|
currentDeposits, _, err := DeterministicDepositsAndKeys(previousDepsLen + numDeposits)
|
|
if err != nil {
|
|
return nil, nil, errors.Wrap(err, "could not get deposits")
|
|
}
|
|
eth1Data, err := DeterministicEth1Data(len(currentDeposits))
|
|
if err != nil {
|
|
return nil, nil, errors.Wrap(err, "could not get eth1data")
|
|
}
|
|
return currentDeposits[previousDepsLen:], eth1Data, nil
|
|
}
|
|
|
|
func generateVoluntaryExits(
|
|
bState state.BeaconState,
|
|
privs []bls.SecretKey,
|
|
numExits uint64,
|
|
) ([]*ethpb.SignedVoluntaryExit, error) {
|
|
currentEpoch := time.CurrentEpoch(bState)
|
|
|
|
voluntaryExits := make([]*ethpb.SignedVoluntaryExit, numExits)
|
|
for i := 0; i < len(voluntaryExits); i++ {
|
|
valIndex, err := randValIndex(bState)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
exit := ðpb.SignedVoluntaryExit{
|
|
Exit: ðpb.VoluntaryExit{
|
|
Epoch: time.PrevEpoch(bState),
|
|
ValidatorIndex: valIndex,
|
|
},
|
|
}
|
|
exit.Signature, err = signing.ComputeDomainAndSign(bState, currentEpoch, exit.Exit, params.BeaconConfig().DomainVoluntaryExit, privs[valIndex])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
voluntaryExits[i] = exit
|
|
}
|
|
return voluntaryExits, nil
|
|
}
|
|
|
|
func randValIndex(bState state.BeaconState) (types.ValidatorIndex, error) {
|
|
activeCount, err := helpers.ActiveValidatorCount(context.Background(), bState, time.CurrentEpoch(bState))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return types.ValidatorIndex(rand.NewGenerator().Uint64() % activeCount), nil
|
|
}
|
|
|
|
// HydrateSignedBeaconHeader hydrates a signed beacon block header with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBeaconHeader(h *ethpb.SignedBeaconBlockHeader) *ethpb.SignedBeaconBlockHeader {
|
|
if h.Signature == nil {
|
|
h.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
h.Header = HydrateBeaconHeader(h.Header)
|
|
return h
|
|
}
|
|
|
|
// HydrateBeaconHeader hydrates a beacon block header with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconHeader(h *ethpb.BeaconBlockHeader) *ethpb.BeaconBlockHeader {
|
|
if h == nil {
|
|
h = ðpb.BeaconBlockHeader{}
|
|
}
|
|
if h.BodyRoot == nil {
|
|
h.BodyRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if h.StateRoot == nil {
|
|
h.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if h.ParentRoot == nil {
|
|
h.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
return h
|
|
}
|
|
|
|
// HydrateSignedBeaconBlock hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBeaconBlock(b *ethpb.SignedBeaconBlock) *ethpb.SignedBeaconBlock {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateBeaconBlock(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlock hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlock(b *ethpb.BeaconBlock) *ethpb.BeaconBlock {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlock{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateBeaconBlockBody(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockBody hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockBody(b *ethpb.BeaconBlockBody) *ethpb.BeaconBlockBody {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockBody{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateV1SignedBeaconBlock hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV1SignedBeaconBlock(b *v1.SignedBeaconBlock) *v1.SignedBeaconBlock {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateV1BeaconBlock(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateV1BeaconBlock hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV1BeaconBlock(b *v1.BeaconBlock) *v1.BeaconBlock {
|
|
if b == nil {
|
|
b = &v1.BeaconBlock{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateV1BeaconBlockBody(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateV1BeaconBlockBody hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV1BeaconBlockBody(b *v1.BeaconBlockBody) *v1.BeaconBlockBody {
|
|
if b == nil {
|
|
b = &v1.BeaconBlockBody{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = &v1.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateV2AltairSignedBeaconBlock hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2AltairSignedBeaconBlock(b *v2.SignedBeaconBlockAltair) *v2.SignedBeaconBlockAltair {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Message = HydrateV2AltairBeaconBlock(b.Message)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2AltairBeaconBlock hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2AltairBeaconBlock(b *v2.BeaconBlockAltair) *v2.BeaconBlockAltair {
|
|
if b == nil {
|
|
b = &v2.BeaconBlockAltair{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateV2AltairBeaconBlockBody(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2AltairBeaconBlockBody hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2AltairBeaconBlockBody(b *v2.BeaconBlockBodyAltair) *v2.BeaconBlockBodyAltair {
|
|
if b == nil {
|
|
b = &v2.BeaconBlockBodyAltair{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = &v1.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = &v1.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, 64),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BellatrixSignedBeaconBlock hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BellatrixSignedBeaconBlock(b *v2.SignedBeaconBlockBellatrix) *v2.SignedBeaconBlockBellatrix {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Message = HydrateV2BellatrixBeaconBlock(b.Message)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BellatrixBeaconBlock hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BellatrixBeaconBlock(b *v2.BeaconBlockBellatrix) *v2.BeaconBlockBellatrix {
|
|
if b == nil {
|
|
b = &v2.BeaconBlockBellatrix{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateV2BellatrixBeaconBlockBody(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BellatrixBeaconBlockBody hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BellatrixBeaconBlockBody(b *v2.BeaconBlockBodyBellatrix) *v2.BeaconBlockBodyBellatrix {
|
|
if b == nil {
|
|
b = &v2.BeaconBlockBodyBellatrix{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = &v1.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = &v1.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, 64),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayload == nil {
|
|
b.ExecutionPayload = &enginev1.ExecutionPayload{
|
|
ParentHash: make([]byte, fieldparams.RootLength),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, fieldparams.RootLength),
|
|
ExtraData: make([]byte, fieldparams.RootLength),
|
|
BaseFeePerGas: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateSignedBeaconBlockAltair hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBeaconBlockAltair(b *ethpb.SignedBeaconBlockAltair) *ethpb.SignedBeaconBlockAltair {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateBeaconBlockAltair(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockAltair hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockAltair(b *ethpb.BeaconBlockAltair) *ethpb.BeaconBlockAltair {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockAltair{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateBeaconBlockBodyAltair(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockBodyAltair hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockBodyAltair(b *ethpb.BeaconBlockBodyAltair) *ethpb.BeaconBlockBodyAltair {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockBodyAltair{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = ðpb.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, 64),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateSignedBeaconBlockBellatrix hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBeaconBlockBellatrix(b *ethpb.SignedBeaconBlockBellatrix) *ethpb.SignedBeaconBlockBellatrix {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateBeaconBlockBellatrix(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockBellatrix hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockBellatrix(b *ethpb.BeaconBlockBellatrix) *ethpb.BeaconBlockBellatrix {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockBellatrix{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateBeaconBlockBodyBellatrix(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockBodyBellatrix hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockBodyBellatrix(b *ethpb.BeaconBlockBodyBellatrix) *ethpb.BeaconBlockBodyBellatrix {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockBodyBellatrix{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = ðpb.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayload == nil {
|
|
b.ExecutionPayload = &enginev1.ExecutionPayload{
|
|
ParentHash: make([]byte, fieldparams.RootLength),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, fieldparams.RootLength),
|
|
BaseFeePerGas: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
Transactions: make([][]byte, 0),
|
|
ExtraData: make([]byte, 0),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateSignedBlindedBeaconBlockBellatrix hydrates a signed blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBlindedBeaconBlockBellatrix(b *ethpb.SignedBlindedBeaconBlockBellatrix) *ethpb.SignedBlindedBeaconBlockBellatrix {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateBlindedBeaconBlockBellatrix(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateBlindedBeaconBlockBellatrix hydrates a blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBlindedBeaconBlockBellatrix(b *ethpb.BlindedBeaconBlockBellatrix) *ethpb.BlindedBeaconBlockBellatrix {
|
|
if b == nil {
|
|
b = ðpb.BlindedBeaconBlockBellatrix{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateBlindedBeaconBlockBodyBellatrix(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateBlindedBeaconBlockBodyBellatrix hydrates a blinded beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBlindedBeaconBlockBodyBellatrix(b *ethpb.BlindedBeaconBlockBodyBellatrix) *ethpb.BlindedBeaconBlockBodyBellatrix {
|
|
if b == nil {
|
|
b = ðpb.BlindedBeaconBlockBodyBellatrix{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, 32)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, 32),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = ðpb.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayloadHeader == nil {
|
|
b.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeader{
|
|
ParentHash: make([]byte, 32),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, 32),
|
|
BaseFeePerGas: make([]byte, 32),
|
|
BlockHash: make([]byte, 32),
|
|
TransactionsRoot: make([]byte, fieldparams.RootLength),
|
|
ExtraData: make([]byte, 0),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateV2SignedBlindedBeaconBlockBellatrix hydrates a signed blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2SignedBlindedBeaconBlockBellatrix(b *v2.SignedBlindedBeaconBlockBellatrix) *v2.SignedBlindedBeaconBlockBellatrix {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Message = HydrateV2BlindedBeaconBlockBellatrix(b.Message)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BlindedBeaconBlockBellatrix hydrates a blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BlindedBeaconBlockBellatrix(b *v2.BlindedBeaconBlockBellatrix) *v2.BlindedBeaconBlockBellatrix {
|
|
if b == nil {
|
|
b = &v2.BlindedBeaconBlockBellatrix{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateV2BlindedBeaconBlockBodyBellatrix(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BlindedBeaconBlockBodyBellatrix hydrates a blinded beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BlindedBeaconBlockBodyBellatrix(b *v2.BlindedBeaconBlockBodyBellatrix) *v2.BlindedBeaconBlockBodyBellatrix {
|
|
if b == nil {
|
|
b = &v2.BlindedBeaconBlockBodyBellatrix{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, 32)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = &v1.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, 32),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = &v1.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, 64),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayloadHeader == nil {
|
|
b.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeader{
|
|
ParentHash: make([]byte, 32),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, 32),
|
|
BaseFeePerGas: make([]byte, 32),
|
|
BlockHash: make([]byte, 32),
|
|
TransactionsRoot: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateSignedBeaconBlockCapella hydrates a signed beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBeaconBlockCapella(b *ethpb.SignedBeaconBlockCapella) *ethpb.SignedBeaconBlockCapella {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateBeaconBlockCapella(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockCapella hydrates a beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockCapella(b *ethpb.BeaconBlockCapella) *ethpb.BeaconBlockCapella {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockCapella{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateBeaconBlockBodyCapella(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateBeaconBlockBodyCapella hydrates a beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBeaconBlockBodyCapella(b *ethpb.BeaconBlockBodyCapella) *ethpb.BeaconBlockBodyCapella {
|
|
if b == nil {
|
|
b = ðpb.BeaconBlockBodyCapella{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = ðpb.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayload == nil {
|
|
b.ExecutionPayload = &enginev1.ExecutionPayloadCapella{
|
|
ParentHash: make([]byte, fieldparams.RootLength),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, fieldparams.RootLength),
|
|
BaseFeePerGas: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, fieldparams.RootLength),
|
|
Transactions: make([][]byte, 0),
|
|
ExtraData: make([]byte, 0),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateSignedBlindedBeaconBlockCapella hydrates a signed blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateSignedBlindedBeaconBlockCapella(b *ethpb.SignedBlindedBeaconBlockCapella) *ethpb.SignedBlindedBeaconBlockCapella {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Block = HydrateBlindedBeaconBlockCapella(b.Block)
|
|
return b
|
|
}
|
|
|
|
// HydrateBlindedBeaconBlockCapella hydrates a blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBlindedBeaconBlockCapella(b *ethpb.BlindedBeaconBlockCapella) *ethpb.BlindedBeaconBlockCapella {
|
|
if b == nil {
|
|
b = ðpb.BlindedBeaconBlockCapella{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateBlindedBeaconBlockBodyCapella(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateBlindedBeaconBlockBodyCapella hydrates a blinded beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateBlindedBeaconBlockBodyCapella(b *ethpb.BlindedBeaconBlockBodyCapella) *ethpb.BlindedBeaconBlockBodyCapella {
|
|
if b == nil {
|
|
b = ðpb.BlindedBeaconBlockBodyCapella{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, 32)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = ðpb.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, 32),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = ðpb.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, fieldparams.SyncAggregateSyncCommitteeBytesLength),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayloadHeader == nil {
|
|
b.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
|
|
ParentHash: make([]byte, 32),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, 32),
|
|
BaseFeePerGas: make([]byte, 32),
|
|
BlockHash: make([]byte, 32),
|
|
TransactionsRoot: make([]byte, fieldparams.RootLength),
|
|
ExtraData: make([]byte, 0),
|
|
WithdrawalsRoot: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
// HydrateV2SignedBlindedBeaconBlockCapella hydrates a signed blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2SignedBlindedBeaconBlockCapella(b *v2.SignedBlindedBeaconBlockCapella) *v2.SignedBlindedBeaconBlockCapella {
|
|
if b.Signature == nil {
|
|
b.Signature = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
b.Message = HydrateV2BlindedBeaconBlockCapella(b.Message)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BlindedBeaconBlockCapella hydrates a blinded beacon block with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BlindedBeaconBlockCapella(b *v2.BlindedBeaconBlockCapella) *v2.BlindedBeaconBlockCapella {
|
|
if b == nil {
|
|
b = &v2.BlindedBeaconBlockCapella{}
|
|
}
|
|
if b.ParentRoot == nil {
|
|
b.ParentRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
if b.StateRoot == nil {
|
|
b.StateRoot = make([]byte, fieldparams.RootLength)
|
|
}
|
|
b.Body = HydrateV2BlindedBeaconBlockBodyCapella(b.Body)
|
|
return b
|
|
}
|
|
|
|
// HydrateV2BlindedBeaconBlockBodyCapella hydrates a blinded beacon block body with correct field length sizes
|
|
// to comply with fssz marshalling and unmarshalling rules.
|
|
func HydrateV2BlindedBeaconBlockBodyCapella(b *v2.BlindedBeaconBlockBodyCapella) *v2.BlindedBeaconBlockBodyCapella {
|
|
if b == nil {
|
|
b = &v2.BlindedBeaconBlockBodyCapella{}
|
|
}
|
|
if b.RandaoReveal == nil {
|
|
b.RandaoReveal = make([]byte, fieldparams.BLSSignatureLength)
|
|
}
|
|
if b.Graffiti == nil {
|
|
b.Graffiti = make([]byte, 32)
|
|
}
|
|
if b.Eth1Data == nil {
|
|
b.Eth1Data = &v1.Eth1Data{
|
|
DepositRoot: make([]byte, fieldparams.RootLength),
|
|
BlockHash: make([]byte, 32),
|
|
}
|
|
}
|
|
if b.SyncAggregate == nil {
|
|
b.SyncAggregate = &v1.SyncAggregate{
|
|
SyncCommitteeBits: make([]byte, 64),
|
|
SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
|
|
}
|
|
}
|
|
if b.ExecutionPayloadHeader == nil {
|
|
b.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
|
|
ParentHash: make([]byte, 32),
|
|
FeeRecipient: make([]byte, 20),
|
|
StateRoot: make([]byte, fieldparams.RootLength),
|
|
ReceiptsRoot: make([]byte, fieldparams.RootLength),
|
|
LogsBloom: make([]byte, 256),
|
|
PrevRandao: make([]byte, 32),
|
|
BaseFeePerGas: make([]byte, 32),
|
|
BlockHash: make([]byte, 32),
|
|
TransactionsRoot: make([]byte, fieldparams.RootLength),
|
|
WithdrawalsRoot: make([]byte, fieldparams.RootLength),
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
func SaveBlock(tb assertions.AssertionTestingTB, ctx context.Context, db iface.NoHeadAccessDatabase, b interface{}) interfaces.SignedBeaconBlock {
|
|
wsb, err := blocks.NewSignedBeaconBlock(b)
|
|
require.NoError(tb, err)
|
|
require.NoError(tb, db.SaveBlock(ctx, wsb))
|
|
return wsb
|
|
}
|