mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2024-12-25 21:07:18 +00:00
dc5fb92b28
* rem other state interfaces * redundant check * gaz Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
518 lines
24 KiB
Go
518 lines
24 KiB
Go
package migration
|
|
|
|
import (
|
|
"github.com/pkg/errors"
|
|
"github.com/prysmaticlabs/prysm/beacon-chain/state"
|
|
"github.com/prysmaticlabs/prysm/encoding/bytesutil"
|
|
"github.com/prysmaticlabs/prysm/encoding/ssz"
|
|
enginev1 "github.com/prysmaticlabs/prysm/proto/engine/v1"
|
|
ethpbv1 "github.com/prysmaticlabs/prysm/proto/eth/v1"
|
|
ethpbv2 "github.com/prysmaticlabs/prysm/proto/eth/v2"
|
|
ethpbalpha "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
// V1Alpha1BeaconBlockAltairToV2 converts a v1alpha1 Altair beacon block to a v2 Altair block.
|
|
func V1Alpha1BeaconBlockAltairToV2(v1alpha1Block *ethpbalpha.BeaconBlockAltair) (*ethpbv2.BeaconBlockAltair, error) {
|
|
marshaledBlk, err := proto.Marshal(v1alpha1Block)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not marshal block")
|
|
}
|
|
v2Block := ðpbv2.BeaconBlockAltair{}
|
|
if err := proto.Unmarshal(marshaledBlk, v2Block); err != nil {
|
|
return nil, errors.Wrap(err, "could not unmarshal block")
|
|
}
|
|
return v2Block, nil
|
|
}
|
|
|
|
// AltairToV1Alpha1SignedBlock converts a v2 SignedBeaconBlockAltair proto to a v1alpha1 proto.
|
|
func AltairToV1Alpha1SignedBlock(altairBlk *ethpbv2.SignedBeaconBlockAltair) (*ethpbalpha.SignedBeaconBlockAltair, error) {
|
|
marshaledBlk, err := proto.Marshal(altairBlk)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not marshal block")
|
|
}
|
|
v1alpha1Block := ðpbalpha.SignedBeaconBlockAltair{}
|
|
if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
|
|
return nil, errors.Wrap(err, "could not unmarshal block")
|
|
}
|
|
return v1alpha1Block, nil
|
|
}
|
|
|
|
// BellatrixToV1Alpha1SignedBlock converts a v2 SignedBeaconBlockBellatrix proto to a v1alpha1 proto.
|
|
func BellatrixToV1Alpha1SignedBlock(bellatrixBlk *ethpbv2.SignedBeaconBlockBellatrix) (*ethpbalpha.SignedBeaconBlockBellatrix, error) {
|
|
marshaledBlk, err := proto.Marshal(bellatrixBlk)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not marshal block")
|
|
}
|
|
v1alpha1Block := ðpbalpha.SignedBeaconBlockBellatrix{}
|
|
if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
|
|
return nil, errors.Wrap(err, "could not unmarshal block")
|
|
}
|
|
return v1alpha1Block, nil
|
|
}
|
|
|
|
// BlindedBellatrixToV1Alpha1SignedBlock converts a v2 SignedBlindedBeaconBlockBellatrix proto to a v1alpha1 proto.
|
|
func BlindedBellatrixToV1Alpha1SignedBlock(bellatrixBlk *ethpbv2.SignedBlindedBeaconBlockBellatrix) (*ethpbalpha.SignedBlindedBeaconBlockBellatrix, error) {
|
|
marshaledBlk, err := proto.Marshal(bellatrixBlk)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not marshal block")
|
|
}
|
|
v1alpha1Block := ðpbalpha.SignedBlindedBeaconBlockBellatrix{}
|
|
if err := proto.Unmarshal(marshaledBlk, v1alpha1Block); err != nil {
|
|
return nil, errors.Wrap(err, "could not unmarshal block")
|
|
}
|
|
return v1alpha1Block, nil
|
|
}
|
|
|
|
// V1Alpha1BeaconBlockBellatrixToV2 converts a v1alpha1 Bellatrix beacon block to a v2
|
|
// Bellatrix block.
|
|
func V1Alpha1BeaconBlockBellatrixToV2(v1alpha1Block *ethpbalpha.BeaconBlockBellatrix) (*ethpbv2.BeaconBlockBellatrix, error) {
|
|
marshaledBlk, err := proto.Marshal(v1alpha1Block)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not marshal block")
|
|
}
|
|
v2Block := ðpbv2.BeaconBlockBellatrix{}
|
|
if err := proto.Unmarshal(marshaledBlk, v2Block); err != nil {
|
|
return nil, errors.Wrap(err, "could not unmarshal block")
|
|
}
|
|
return v2Block, nil
|
|
}
|
|
|
|
// V1Alpha1BeaconBlockBellatrixToV2Blinded converts a v1alpha1 Bellatrix beacon block to a v2
|
|
// blinded Bellatrix block.
|
|
func V1Alpha1BeaconBlockBellatrixToV2Blinded(v1alpha1Block *ethpbalpha.BeaconBlockBellatrix) (*ethpbv2.BlindedBeaconBlockBellatrix, error) {
|
|
sourceProposerSlashings := v1alpha1Block.Body.ProposerSlashings
|
|
resultProposerSlashings := make([]*ethpbv1.ProposerSlashing, len(sourceProposerSlashings))
|
|
for i, s := range sourceProposerSlashings {
|
|
resultProposerSlashings[i] = ðpbv1.ProposerSlashing{
|
|
SignedHeader_1: ðpbv1.SignedBeaconBlockHeader{
|
|
Message: ðpbv1.BeaconBlockHeader{
|
|
Slot: s.Header_1.Header.Slot,
|
|
ProposerIndex: s.Header_1.Header.ProposerIndex,
|
|
ParentRoot: bytesutil.SafeCopyBytes(s.Header_1.Header.ParentRoot),
|
|
StateRoot: bytesutil.SafeCopyBytes(s.Header_1.Header.StateRoot),
|
|
BodyRoot: bytesutil.SafeCopyBytes(s.Header_1.Header.BodyRoot),
|
|
},
|
|
Signature: bytesutil.SafeCopyBytes(s.Header_1.Signature),
|
|
},
|
|
SignedHeader_2: ðpbv1.SignedBeaconBlockHeader{
|
|
Message: ðpbv1.BeaconBlockHeader{
|
|
Slot: s.Header_2.Header.Slot,
|
|
ProposerIndex: s.Header_2.Header.ProposerIndex,
|
|
ParentRoot: bytesutil.SafeCopyBytes(s.Header_2.Header.ParentRoot),
|
|
StateRoot: bytesutil.SafeCopyBytes(s.Header_2.Header.StateRoot),
|
|
BodyRoot: bytesutil.SafeCopyBytes(s.Header_2.Header.BodyRoot),
|
|
},
|
|
Signature: bytesutil.SafeCopyBytes(s.Header_2.Signature),
|
|
},
|
|
}
|
|
}
|
|
|
|
sourceAttesterSlashings := v1alpha1Block.Body.AttesterSlashings
|
|
resultAttesterSlashings := make([]*ethpbv1.AttesterSlashing, len(sourceAttesterSlashings))
|
|
for i, s := range sourceAttesterSlashings {
|
|
att1Indices := make([]uint64, len(s.Attestation_1.AttestingIndices))
|
|
copy(att1Indices, s.Attestation_1.AttestingIndices)
|
|
att2Indices := make([]uint64, len(s.Attestation_2.AttestingIndices))
|
|
copy(att2Indices, s.Attestation_2.AttestingIndices)
|
|
resultAttesterSlashings[i] = ðpbv1.AttesterSlashing{
|
|
Attestation_1: ðpbv1.IndexedAttestation{
|
|
AttestingIndices: att1Indices,
|
|
Data: ðpbv1.AttestationData{
|
|
Slot: s.Attestation_1.Data.Slot,
|
|
Index: s.Attestation_1.Data.CommitteeIndex,
|
|
BeaconBlockRoot: bytesutil.SafeCopyBytes(s.Attestation_1.Data.BeaconBlockRoot),
|
|
Source: ðpbv1.Checkpoint{
|
|
Epoch: s.Attestation_1.Data.Source.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(s.Attestation_1.Data.Source.Root),
|
|
},
|
|
Target: ðpbv1.Checkpoint{
|
|
Epoch: s.Attestation_1.Data.Target.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(s.Attestation_1.Data.Target.Root),
|
|
},
|
|
},
|
|
Signature: bytesutil.SafeCopyBytes(s.Attestation_1.Signature),
|
|
},
|
|
Attestation_2: ðpbv1.IndexedAttestation{
|
|
AttestingIndices: att2Indices,
|
|
Data: ðpbv1.AttestationData{
|
|
Slot: s.Attestation_2.Data.Slot,
|
|
Index: s.Attestation_2.Data.CommitteeIndex,
|
|
BeaconBlockRoot: bytesutil.SafeCopyBytes(s.Attestation_2.Data.BeaconBlockRoot),
|
|
Source: ðpbv1.Checkpoint{
|
|
Epoch: s.Attestation_2.Data.Source.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(s.Attestation_2.Data.Source.Root),
|
|
},
|
|
Target: ðpbv1.Checkpoint{
|
|
Epoch: s.Attestation_2.Data.Target.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(s.Attestation_2.Data.Target.Root),
|
|
},
|
|
},
|
|
Signature: bytesutil.SafeCopyBytes(s.Attestation_2.Signature),
|
|
},
|
|
}
|
|
}
|
|
|
|
sourceAttestations := v1alpha1Block.Body.Attestations
|
|
resultAttestations := make([]*ethpbv1.Attestation, len(sourceAttestations))
|
|
for i, a := range sourceAttestations {
|
|
resultAttestations[i] = ðpbv1.Attestation{
|
|
AggregationBits: bytesutil.SafeCopyBytes(a.AggregationBits),
|
|
Data: ðpbv1.AttestationData{
|
|
Slot: a.Data.Slot,
|
|
Index: a.Data.CommitteeIndex,
|
|
BeaconBlockRoot: bytesutil.SafeCopyBytes(a.Data.BeaconBlockRoot),
|
|
Source: ðpbv1.Checkpoint{
|
|
Epoch: a.Data.Source.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(a.Data.Source.Root),
|
|
},
|
|
Target: ðpbv1.Checkpoint{
|
|
Epoch: a.Data.Target.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(a.Data.Target.Root),
|
|
},
|
|
},
|
|
Signature: bytesutil.SafeCopyBytes(a.Signature),
|
|
}
|
|
}
|
|
|
|
sourceDeposits := v1alpha1Block.Body.Deposits
|
|
resultDeposits := make([]*ethpbv1.Deposit, len(sourceDeposits))
|
|
for i, d := range sourceDeposits {
|
|
resultDeposits[i] = ðpbv1.Deposit{
|
|
Proof: bytesutil.SafeCopy2dBytes(d.Proof),
|
|
Data: ðpbv1.Deposit_Data{
|
|
Pubkey: bytesutil.SafeCopyBytes(d.Data.PublicKey),
|
|
WithdrawalCredentials: bytesutil.SafeCopyBytes(d.Data.WithdrawalCredentials),
|
|
Amount: d.Data.Amount,
|
|
Signature: bytesutil.SafeCopyBytes(d.Data.Signature),
|
|
},
|
|
}
|
|
}
|
|
|
|
sourceExits := v1alpha1Block.Body.VoluntaryExits
|
|
resultExits := make([]*ethpbv1.SignedVoluntaryExit, len(sourceExits))
|
|
for i, e := range sourceExits {
|
|
resultExits[i] = ðpbv1.SignedVoluntaryExit{
|
|
Message: ðpbv1.VoluntaryExit{
|
|
Epoch: e.Exit.Epoch,
|
|
ValidatorIndex: e.Exit.ValidatorIndex,
|
|
},
|
|
Signature: bytesutil.SafeCopyBytes(e.Signature),
|
|
}
|
|
}
|
|
|
|
transactionsRoot, err := ssz.TransactionsRoot(v1alpha1Block.Body.ExecutionPayload.Transactions)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "could not calculate transactions root")
|
|
}
|
|
|
|
resultBlockBody := ðpbv2.BlindedBeaconBlockBodyBellatrix{
|
|
RandaoReveal: bytesutil.SafeCopyBytes(v1alpha1Block.Body.RandaoReveal),
|
|
Eth1Data: ðpbv1.Eth1Data{
|
|
DepositRoot: bytesutil.SafeCopyBytes(v1alpha1Block.Body.Eth1Data.DepositRoot),
|
|
DepositCount: v1alpha1Block.Body.Eth1Data.DepositCount,
|
|
BlockHash: bytesutil.SafeCopyBytes(v1alpha1Block.Body.Eth1Data.BlockHash),
|
|
},
|
|
Graffiti: bytesutil.SafeCopyBytes(v1alpha1Block.Body.Graffiti),
|
|
ProposerSlashings: resultProposerSlashings,
|
|
AttesterSlashings: resultAttesterSlashings,
|
|
Attestations: resultAttestations,
|
|
Deposits: resultDeposits,
|
|
VoluntaryExits: resultExits,
|
|
SyncAggregate: ðpbv1.SyncAggregate{
|
|
SyncCommitteeBits: bytesutil.SafeCopyBytes(v1alpha1Block.Body.SyncAggregate.SyncCommitteeBits),
|
|
SyncCommitteeSignature: bytesutil.SafeCopyBytes(v1alpha1Block.Body.SyncAggregate.SyncCommitteeSignature),
|
|
},
|
|
ExecutionPayloadHeader: &enginev1.ExecutionPayloadHeader{
|
|
ParentHash: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.ParentHash),
|
|
FeeRecipient: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.FeeRecipient),
|
|
StateRoot: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.StateRoot),
|
|
ReceiptsRoot: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.ReceiptsRoot),
|
|
LogsBloom: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.LogsBloom),
|
|
PrevRandao: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.PrevRandao),
|
|
BlockNumber: v1alpha1Block.Body.ExecutionPayload.BlockNumber,
|
|
GasLimit: v1alpha1Block.Body.ExecutionPayload.GasLimit,
|
|
GasUsed: v1alpha1Block.Body.ExecutionPayload.GasUsed,
|
|
Timestamp: v1alpha1Block.Body.ExecutionPayload.Timestamp,
|
|
ExtraData: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.ExtraData),
|
|
BaseFeePerGas: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.BaseFeePerGas),
|
|
BlockHash: bytesutil.SafeCopyBytes(v1alpha1Block.Body.ExecutionPayload.BlockHash),
|
|
TransactionsRoot: transactionsRoot[:],
|
|
},
|
|
}
|
|
v2Block := ðpbv2.BlindedBeaconBlockBellatrix{
|
|
Slot: v1alpha1Block.Slot,
|
|
ProposerIndex: v1alpha1Block.ProposerIndex,
|
|
ParentRoot: bytesutil.SafeCopyBytes(v1alpha1Block.ParentRoot),
|
|
StateRoot: bytesutil.SafeCopyBytes(v1alpha1Block.StateRoot),
|
|
Body: resultBlockBody,
|
|
}
|
|
return v2Block, nil
|
|
}
|
|
|
|
// BeaconStateAltairToProto converts a state.BeaconState object to its protobuf equivalent.
|
|
func BeaconStateAltairToProto(altairState state.BeaconState) (*ethpbv2.BeaconStateV2, error) {
|
|
sourceFork := altairState.Fork()
|
|
sourceLatestBlockHeader := altairState.LatestBlockHeader()
|
|
sourceEth1Data := altairState.Eth1Data()
|
|
sourceEth1DataVotes := altairState.Eth1DataVotes()
|
|
sourceValidators := altairState.Validators()
|
|
sourceJustificationBits := altairState.JustificationBits()
|
|
sourcePrevJustifiedCheckpoint := altairState.PreviousJustifiedCheckpoint()
|
|
sourceCurrJustifiedCheckpoint := altairState.CurrentJustifiedCheckpoint()
|
|
sourceFinalizedCheckpoint := altairState.FinalizedCheckpoint()
|
|
|
|
resultEth1DataVotes := make([]*ethpbv1.Eth1Data, len(sourceEth1DataVotes))
|
|
for i, vote := range sourceEth1DataVotes {
|
|
resultEth1DataVotes[i] = ðpbv1.Eth1Data{
|
|
DepositRoot: bytesutil.SafeCopyBytes(vote.DepositRoot),
|
|
DepositCount: vote.DepositCount,
|
|
BlockHash: bytesutil.SafeCopyBytes(vote.BlockHash),
|
|
}
|
|
}
|
|
resultValidators := make([]*ethpbv1.Validator, len(sourceValidators))
|
|
for i, validator := range sourceValidators {
|
|
resultValidators[i] = ðpbv1.Validator{
|
|
Pubkey: bytesutil.SafeCopyBytes(validator.PublicKey),
|
|
WithdrawalCredentials: bytesutil.SafeCopyBytes(validator.WithdrawalCredentials),
|
|
EffectiveBalance: validator.EffectiveBalance,
|
|
Slashed: validator.Slashed,
|
|
ActivationEligibilityEpoch: validator.ActivationEligibilityEpoch,
|
|
ActivationEpoch: validator.ActivationEpoch,
|
|
ExitEpoch: validator.ExitEpoch,
|
|
WithdrawableEpoch: validator.WithdrawableEpoch,
|
|
}
|
|
}
|
|
|
|
sourcePrevEpochParticipation, err := altairState.PreviousEpochParticipation()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get previous epoch participation")
|
|
}
|
|
sourceCurrEpochParticipation, err := altairState.CurrentEpochParticipation()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get current epoch participation")
|
|
}
|
|
sourceInactivityScores, err := altairState.InactivityScores()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get inactivity scores")
|
|
}
|
|
sourceCurrSyncCommittee, err := altairState.CurrentSyncCommittee()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get current sync committee")
|
|
}
|
|
sourceNextSyncCommittee, err := altairState.NextSyncCommittee()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get next sync committee")
|
|
}
|
|
|
|
result := ðpbv2.BeaconStateV2{
|
|
GenesisTime: altairState.GenesisTime(),
|
|
GenesisValidatorsRoot: bytesutil.SafeCopyBytes(altairState.GenesisValidatorsRoot()),
|
|
Slot: altairState.Slot(),
|
|
Fork: ðpbv1.Fork{
|
|
PreviousVersion: bytesutil.SafeCopyBytes(sourceFork.PreviousVersion),
|
|
CurrentVersion: bytesutil.SafeCopyBytes(sourceFork.CurrentVersion),
|
|
Epoch: sourceFork.Epoch,
|
|
},
|
|
LatestBlockHeader: ðpbv1.BeaconBlockHeader{
|
|
Slot: sourceLatestBlockHeader.Slot,
|
|
ProposerIndex: sourceLatestBlockHeader.ProposerIndex,
|
|
ParentRoot: bytesutil.SafeCopyBytes(sourceLatestBlockHeader.ParentRoot),
|
|
StateRoot: bytesutil.SafeCopyBytes(sourceLatestBlockHeader.StateRoot),
|
|
BodyRoot: bytesutil.SafeCopyBytes(sourceLatestBlockHeader.BodyRoot),
|
|
},
|
|
BlockRoots: bytesutil.SafeCopy2dBytes(altairState.BlockRoots()),
|
|
StateRoots: bytesutil.SafeCopy2dBytes(altairState.StateRoots()),
|
|
HistoricalRoots: bytesutil.SafeCopy2dBytes(altairState.HistoricalRoots()),
|
|
Eth1Data: ðpbv1.Eth1Data{
|
|
DepositRoot: bytesutil.SafeCopyBytes(sourceEth1Data.DepositRoot),
|
|
DepositCount: sourceEth1Data.DepositCount,
|
|
BlockHash: bytesutil.SafeCopyBytes(sourceEth1Data.BlockHash),
|
|
},
|
|
Eth1DataVotes: resultEth1DataVotes,
|
|
Eth1DepositIndex: altairState.Eth1DepositIndex(),
|
|
Validators: resultValidators,
|
|
Balances: altairState.Balances(),
|
|
RandaoMixes: bytesutil.SafeCopy2dBytes(altairState.RandaoMixes()),
|
|
Slashings: altairState.Slashings(),
|
|
PreviousEpochParticipation: bytesutil.SafeCopyBytes(sourcePrevEpochParticipation),
|
|
CurrentEpochParticipation: bytesutil.SafeCopyBytes(sourceCurrEpochParticipation),
|
|
JustificationBits: bytesutil.SafeCopyBytes(sourceJustificationBits),
|
|
PreviousJustifiedCheckpoint: ðpbv1.Checkpoint{
|
|
Epoch: sourcePrevJustifiedCheckpoint.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(sourcePrevJustifiedCheckpoint.Root),
|
|
},
|
|
CurrentJustifiedCheckpoint: ðpbv1.Checkpoint{
|
|
Epoch: sourceCurrJustifiedCheckpoint.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(sourceCurrJustifiedCheckpoint.Root),
|
|
},
|
|
FinalizedCheckpoint: ðpbv1.Checkpoint{
|
|
Epoch: sourceFinalizedCheckpoint.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(sourceFinalizedCheckpoint.Root),
|
|
},
|
|
InactivityScores: sourceInactivityScores,
|
|
CurrentSyncCommittee: ðpbv2.SyncCommittee{
|
|
Pubkeys: bytesutil.SafeCopy2dBytes(sourceCurrSyncCommittee.Pubkeys),
|
|
AggregatePubkey: bytesutil.SafeCopyBytes(sourceCurrSyncCommittee.AggregatePubkey),
|
|
},
|
|
NextSyncCommittee: ðpbv2.SyncCommittee{
|
|
Pubkeys: bytesutil.SafeCopy2dBytes(sourceNextSyncCommittee.Pubkeys),
|
|
AggregatePubkey: bytesutil.SafeCopyBytes(sourceNextSyncCommittee.AggregatePubkey),
|
|
},
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// BeaconStateBellatrixToProto converts a state.BeaconState object to its protobuf equivalent.
|
|
func BeaconStateBellatrixToProto(st state.BeaconState) (*ethpbv2.BeaconStateBellatrix, error) {
|
|
sourceFork := st.Fork()
|
|
sourceLatestBlockHeader := st.LatestBlockHeader()
|
|
sourceEth1Data := st.Eth1Data()
|
|
sourceEth1DataVotes := st.Eth1DataVotes()
|
|
sourceValidators := st.Validators()
|
|
sourceJustificationBits := st.JustificationBits()
|
|
sourcePrevJustifiedCheckpoint := st.PreviousJustifiedCheckpoint()
|
|
sourceCurrJustifiedCheckpoint := st.CurrentJustifiedCheckpoint()
|
|
sourceFinalizedCheckpoint := st.FinalizedCheckpoint()
|
|
|
|
resultEth1DataVotes := make([]*ethpbv1.Eth1Data, len(sourceEth1DataVotes))
|
|
for i, vote := range sourceEth1DataVotes {
|
|
resultEth1DataVotes[i] = ðpbv1.Eth1Data{
|
|
DepositRoot: bytesutil.SafeCopyBytes(vote.DepositRoot),
|
|
DepositCount: vote.DepositCount,
|
|
BlockHash: bytesutil.SafeCopyBytes(vote.BlockHash),
|
|
}
|
|
}
|
|
resultValidators := make([]*ethpbv1.Validator, len(sourceValidators))
|
|
for i, validator := range sourceValidators {
|
|
resultValidators[i] = ðpbv1.Validator{
|
|
Pubkey: bytesutil.SafeCopyBytes(validator.PublicKey),
|
|
WithdrawalCredentials: bytesutil.SafeCopyBytes(validator.WithdrawalCredentials),
|
|
EffectiveBalance: validator.EffectiveBalance,
|
|
Slashed: validator.Slashed,
|
|
ActivationEligibilityEpoch: validator.ActivationEligibilityEpoch,
|
|
ActivationEpoch: validator.ActivationEpoch,
|
|
ExitEpoch: validator.ExitEpoch,
|
|
WithdrawableEpoch: validator.WithdrawableEpoch,
|
|
}
|
|
}
|
|
|
|
sourcePrevEpochParticipation, err := st.PreviousEpochParticipation()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get previous epoch participation")
|
|
}
|
|
sourceCurrEpochParticipation, err := st.CurrentEpochParticipation()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get current epoch participation")
|
|
}
|
|
sourceInactivityScores, err := st.InactivityScores()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get inactivity scores")
|
|
}
|
|
sourceCurrSyncCommittee, err := st.CurrentSyncCommittee()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get current sync committee")
|
|
}
|
|
sourceNextSyncCommittee, err := st.NextSyncCommittee()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get next sync committee")
|
|
}
|
|
sourceLatestExecutionPaylodHeader, err := st.LatestExecutionPayloadHeader()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not get latest execution payload header")
|
|
}
|
|
|
|
result := ðpbv2.BeaconStateBellatrix{
|
|
GenesisTime: st.GenesisTime(),
|
|
GenesisValidatorsRoot: bytesutil.SafeCopyBytes(st.GenesisValidatorsRoot()),
|
|
Slot: st.Slot(),
|
|
Fork: ðpbv1.Fork{
|
|
PreviousVersion: bytesutil.SafeCopyBytes(sourceFork.PreviousVersion),
|
|
CurrentVersion: bytesutil.SafeCopyBytes(sourceFork.CurrentVersion),
|
|
Epoch: sourceFork.Epoch,
|
|
},
|
|
LatestBlockHeader: ðpbv1.BeaconBlockHeader{
|
|
Slot: sourceLatestBlockHeader.Slot,
|
|
ProposerIndex: sourceLatestBlockHeader.ProposerIndex,
|
|
ParentRoot: bytesutil.SafeCopyBytes(sourceLatestBlockHeader.ParentRoot),
|
|
StateRoot: bytesutil.SafeCopyBytes(sourceLatestBlockHeader.StateRoot),
|
|
BodyRoot: bytesutil.SafeCopyBytes(sourceLatestBlockHeader.BodyRoot),
|
|
},
|
|
BlockRoots: bytesutil.SafeCopy2dBytes(st.BlockRoots()),
|
|
StateRoots: bytesutil.SafeCopy2dBytes(st.StateRoots()),
|
|
HistoricalRoots: bytesutil.SafeCopy2dBytes(st.HistoricalRoots()),
|
|
Eth1Data: ðpbv1.Eth1Data{
|
|
DepositRoot: bytesutil.SafeCopyBytes(sourceEth1Data.DepositRoot),
|
|
DepositCount: sourceEth1Data.DepositCount,
|
|
BlockHash: bytesutil.SafeCopyBytes(sourceEth1Data.BlockHash),
|
|
},
|
|
Eth1DataVotes: resultEth1DataVotes,
|
|
Eth1DepositIndex: st.Eth1DepositIndex(),
|
|
Validators: resultValidators,
|
|
Balances: st.Balances(),
|
|
RandaoMixes: bytesutil.SafeCopy2dBytes(st.RandaoMixes()),
|
|
Slashings: st.Slashings(),
|
|
PreviousEpochParticipation: bytesutil.SafeCopyBytes(sourcePrevEpochParticipation),
|
|
CurrentEpochParticipation: bytesutil.SafeCopyBytes(sourceCurrEpochParticipation),
|
|
JustificationBits: bytesutil.SafeCopyBytes(sourceJustificationBits),
|
|
PreviousJustifiedCheckpoint: ðpbv1.Checkpoint{
|
|
Epoch: sourcePrevJustifiedCheckpoint.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(sourcePrevJustifiedCheckpoint.Root),
|
|
},
|
|
CurrentJustifiedCheckpoint: ðpbv1.Checkpoint{
|
|
Epoch: sourceCurrJustifiedCheckpoint.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(sourceCurrJustifiedCheckpoint.Root),
|
|
},
|
|
FinalizedCheckpoint: ðpbv1.Checkpoint{
|
|
Epoch: sourceFinalizedCheckpoint.Epoch,
|
|
Root: bytesutil.SafeCopyBytes(sourceFinalizedCheckpoint.Root),
|
|
},
|
|
InactivityScores: sourceInactivityScores,
|
|
CurrentSyncCommittee: ðpbv2.SyncCommittee{
|
|
Pubkeys: bytesutil.SafeCopy2dBytes(sourceCurrSyncCommittee.Pubkeys),
|
|
AggregatePubkey: bytesutil.SafeCopyBytes(sourceCurrSyncCommittee.AggregatePubkey),
|
|
},
|
|
NextSyncCommittee: ðpbv2.SyncCommittee{
|
|
Pubkeys: bytesutil.SafeCopy2dBytes(sourceNextSyncCommittee.Pubkeys),
|
|
AggregatePubkey: bytesutil.SafeCopyBytes(sourceNextSyncCommittee.AggregatePubkey),
|
|
},
|
|
LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeader{
|
|
ParentHash: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.ParentHash),
|
|
FeeRecipient: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.FeeRecipient),
|
|
StateRoot: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.StateRoot),
|
|
ReceiptsRoot: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.ReceiptsRoot),
|
|
LogsBloom: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.LogsBloom),
|
|
PrevRandao: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.PrevRandao),
|
|
BlockNumber: sourceLatestExecutionPaylodHeader.BlockNumber,
|
|
GasLimit: sourceLatestExecutionPaylodHeader.GasLimit,
|
|
GasUsed: sourceLatestExecutionPaylodHeader.GasUsed,
|
|
Timestamp: sourceLatestExecutionPaylodHeader.Timestamp,
|
|
ExtraData: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.ExtraData),
|
|
BaseFeePerGas: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.BaseFeePerGas),
|
|
BlockHash: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.BlockHash),
|
|
TransactionsRoot: bytesutil.SafeCopyBytes(sourceLatestExecutionPaylodHeader.TransactionsRoot),
|
|
},
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func V1Alpha1SignedContributionAndProofToV2(alphaContribution *ethpbalpha.SignedContributionAndProof) *ethpbv2.SignedContributionAndProof {
|
|
result := ðpbv2.SignedContributionAndProof{
|
|
Message: ðpbv2.ContributionAndProof{
|
|
AggregatorIndex: alphaContribution.Message.AggregatorIndex,
|
|
Contribution: ðpbv2.SyncCommitteeContribution{
|
|
Slot: alphaContribution.Message.Contribution.Slot,
|
|
BeaconBlockRoot: alphaContribution.Message.Contribution.BlockRoot,
|
|
SubcommitteeIndex: alphaContribution.Message.Contribution.SubcommitteeIndex,
|
|
AggregationBits: alphaContribution.Message.Contribution.AggregationBits,
|
|
Signature: alphaContribution.Message.Contribution.Signature,
|
|
},
|
|
SelectionProof: alphaContribution.Message.SelectionProof,
|
|
},
|
|
Signature: alphaContribution.Signature,
|
|
}
|
|
return result
|
|
}
|