chore(types): remove ExecutionPayloadHeader version

cli/commands/genesis/genesis.go

@@ -44,7 +44,7 @@ func Commands(
 	cmd.AddCommand(
 		AddGenesisDepositCmd(csc),
 		CollectGenesisDepositsCmd(),
-		AddExecutionPayloadCmd(csc),
+		AddExecutionPayloadCmd(),
 		GetGenesisValidatorRootCmd(csc),
 		SetDepositStorageCmd(csc),
 	)

cli/commands/genesis/payload.go

@@ -22,9 +22,7 @@ package genesis
 
 import (
 	"fmt"
-	"unsafe"
 
-	servertypes "github.com/berachain/beacon-kit/cli/commands/server/types"
 	"github.com/berachain/beacon-kit/cli/context"
 	"github.com/berachain/beacon-kit/consensus-types/types"
 	engineprimitives "github.com/berachain/beacon-kit/engine-primitives/engine-primitives"
@@ -34,172 +32,130 @@ import (
 	"github.com/berachain/beacon-kit/primitives/constants"
 	"github.com/berachain/beacon-kit/primitives/encoding/json"
 	"github.com/berachain/beacon-kit/primitives/math"
-	"github.com/berachain/beacon-kit/primitives/version"
 	cmtcfg "github.com/cometbft/cometbft/config"
 	"github.com/cosmos/cosmos-sdk/x/genutil"
 	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 )
 
-func AddExecutionPayloadCmd(chainSpecCreator servertypes.ChainSpecCreator) *cobra.Command {
+func AddExecutionPayloadCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "execution-payload [eth/genesis/file.json]",
 		Short: "adds the eth1 genesis execution payload to the genesis file",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// Read the genesis file.
-			elGenesisPath := args[0]
-			config := context.GetConfigFromCmd(cmd)
-			v := context.GetViperFromCmd(cmd)
-			chainSpec, err := chainSpecCreator(v)
-			if err != nil {
-				return err
-			}
-			return AddExecutionPayload(chainSpec, elGenesisPath, config)
+			return AddExecutionPayload(args[0], context.GetConfigFromCmd(cmd))
 		},
 	}
 
 	return cmd
 }
 
-func AddExecutionPayload(chainSpec ChainSpec, elGenesisPath string, config *cmtcfg.Config) error {
+func AddExecutionPayload(elGenesisPath string, config *cmtcfg.Config) error {
 	genesisBz, err := afero.ReadFile(afero.NewOsFs(), elGenesisPath)
 	if err != nil {
 		return errors.Wrap(err, "failed to read eth1 genesis file")
 	}
 
-	// Unmarshal the genesis file.
+	// Unmarshal the EL genesis file.
 	ethGenesis := &gethprimitives.Genesis{}
 	if err = ethGenesis.UnmarshalJSON(genesisBz); err != nil {
 		return errors.Wrap(err, "failed to unmarshal eth1 genesis")
 	}
 	genesisBlock := ethGenesis.ToBlock()
 
-	// Create the execution payload.
+	// Create the executable data from the EL genesis file.
 	payload := gethprimitives.BlockToExecutableData(
 		genesisBlock,
 		nil,
 		nil,
 		nil,
 	).ExecutionPayload
 
-	appGenesis, err := genutiltypes.AppGenesisFromFile(
-		config.GenesisFile(),
-	)
+	appGenesis, err := genutiltypes.AppGenesisFromFile(config.GenesisFile())
 	if err != nil {
 		return errors.Wrap(err, "failed to read genesis doc from file")
 	}
 
-	// create the app state
-	appGenesisState, err := genutiltypes.GenesisStateFromAppGenesis(
-		appGenesis,
-	)
+	// Create the app state.
+	appGenesisState, err := genutiltypes.GenesisStateFromAppGenesis(appGenesis)
 	if err != nil {
 		return err
 	}
 
 	genesisInfo := &types.Genesis{}
-
-	if err = json.Unmarshal(
-		appGenesisState["beacon"], genesisInfo,
-	); err != nil {
+	if err = json.Unmarshal(appGenesisState["beacon"], genesisInfo); err != nil {
 		return errors.Wrap(err, "failed to unmarshal beacon state")
 	}
-	// Inject the execution payload.
-	eph, err := executableDataToExecutionPayloadHeader(
-		chainSpec.GenesisForkVersion(),
-		payload,
-		chainSpec.MaxWithdrawalsPerPayload(),
-	)
+
+	// Inject the execution payload from the executable data.
+	eph, err := executableDataToExecutionPayloadHeader(payload)
 	if err != nil {
 		return errors.Wrap(err, "failed to convert executable data to execution payload header")
 	}
-	if eph == nil {
-		return errors.New("failed to get execution payload header")
-	}
 	genesisInfo.ExecutionPayloadHeader = eph
 
-	appGenesisState["beacon"], err = json.Marshal(genesisInfo)
-	if err != nil {
+	if appGenesisState["beacon"], err = json.Marshal(genesisInfo); err != nil {
 		return errors.Wrap(err, "failed to marshal beacon state")
 	}
 
-	if appGenesis.AppState, err = json.MarshalIndent(
-		appGenesisState, "", "  ",
-	); err != nil {
+	if appGenesis.AppState, err = json.MarshalIndent(appGenesisState, "", "  "); err != nil {
 		return err
 	}
 
 	return genutil.ExportGenesisFile(appGenesis, config.GenesisFile())
 }
 
-// Converts the eth executable data type to the beacon execution payload header
-// interface.
+// Converts the eth executable data type to the beacon execution payload header.
 func executableDataToExecutionPayloadHeader(
-	forkVersion common.Version,
 	data *gethprimitives.ExecutableData,
-	// todo: re-enable when codec supports.
-	_ uint64,
 ) (*types.ExecutionPayloadHeader, error) {
-	eph := &types.ExecutionPayloadHeader{}
-
-	// We do not support fork versions before Deneb and after Electra.
-	if version.IsAfter(forkVersion, version.Electra()) ||
-		version.IsBefore(forkVersion, version.Deneb()) {
-		return nil, types.ErrForkVersionNotSupported
-	}
-
-	withdrawals := make(
-		engineprimitives.Withdrawals,
-		len(data.Withdrawals),
-	)
+	eph := &types.ExecutionPayloadHeader{
+		ParentHash:       common.ExecutionHash(data.ParentHash),
+		FeeRecipient:     common.ExecutionAddress(data.FeeRecipient),
+		StateRoot:        common.Bytes32(data.StateRoot),
+		ReceiptsRoot:     common.Bytes32(data.ReceiptsRoot),
+		LogsBloom:        [256]byte(data.LogsBloom),
+		Random:           common.Bytes32(data.Random),
+		Number:           math.U64(data.Number),
+		GasLimit:         math.U64(data.GasLimit),
+		GasUsed:          math.U64(data.GasUsed),
+		Timestamp:        math.U64(data.Timestamp),
+		ExtraData:        data.ExtraData,
+		BlockHash:        common.ExecutionHash(data.BlockHash),
+		TransactionsRoot: engineprimitives.Transactions(data.Transactions).HashTreeRoot(),
+	}
+
+	withdrawals := make(engineprimitives.Withdrawals, len(data.Withdrawals))
 	for i, withdrawal := range data.Withdrawals {
-		// #nosec:G103 // primitives.Withdrawals is data.Withdrawals with
-		// hard
-		// types.
-		withdrawals[i] = (*engineprimitives.Withdrawal)(
-			unsafe.Pointer(withdrawal),
-		)
+		withdrawals[i] = &engineprimitives.Withdrawal{
+			Index:     math.U64(withdrawal.Index),
+			Validator: math.ValidatorIndex(withdrawal.Validator),
+			Address:   common.ExecutionAddress(withdrawal.Address),
+			Amount:    math.Gwei(withdrawal.Amount),
+		}
 	}
+	eph.WithdrawalsRoot = withdrawals.HashTreeRoot()
 
 	if len(data.ExtraData) > constants.ExtraDataLength {
 		data.ExtraData = data.ExtraData[:constants.ExtraDataLength]
 	}
+	eph.ExtraData = data.ExtraData
 
-	var blobGasUsed uint64
 	if data.BlobGasUsed != nil {
-		blobGasUsed = *data.BlobGasUsed
+		eph.BlobGasUsed = math.U64(*data.BlobGasUsed)
 	}
 
-	var excessBlobGas uint64
 	if data.ExcessBlobGas != nil {
-		excessBlobGas = *data.ExcessBlobGas
+		eph.ExcessBlobGas = math.U64(*data.ExcessBlobGas)
 	}
 
 	baseFeePerGas, err := math.NewU256FromBigInt(data.BaseFeePerGas)
 	if err != nil {
 		return nil, fmt.Errorf("failed baseFeePerGas conversion: %w", err)
 	}
-
-	eph.Versionable = types.NewVersionable(forkVersion)
-	eph.ParentHash = common.ExecutionHash(data.ParentHash)
-	eph.FeeRecipient = common.ExecutionAddress(data.FeeRecipient)
-	eph.StateRoot = common.Bytes32(data.StateRoot)
-	eph.ReceiptsRoot = common.Bytes32(data.ReceiptsRoot)
-	eph.LogsBloom = [256]byte(data.LogsBloom)
-	eph.Random = common.Bytes32(data.Random)
-	eph.Number = math.U64(data.Number)
-	eph.GasLimit = math.U64(data.GasLimit)
-	eph.GasUsed = math.U64(data.GasUsed)
-	eph.Timestamp = math.U64(data.Timestamp)
-	eph.ExtraData = data.ExtraData
 	eph.BaseFeePerGas = baseFeePerGas
-	eph.BlockHash = common.ExecutionHash(data.BlockHash)
-	eph.TransactionsRoot = engineprimitives.Transactions(data.Transactions).HashTreeRoot()
-	eph.WithdrawalsRoot = withdrawals.HashTreeRoot()
-	eph.BlobGasUsed = math.U64(blobGasUsed)
-	eph.ExcessBlobGas = math.U64(excessBlobGas)
 
 	return eph, nil
 }

cli/utils/genesis/root_test.go

@@ -108,7 +108,7 @@ func TestCompareGenesisCmdWithStateProcessor(t *testing.T) {
 
 				// genesis validators root from StateProcessor
 				sp, st, _, _, _, _ := statetransition.SetupTestState(t, cs)
-				genPayloadHeader := types.NewEmptyExecutionPayloadHeaderWithVersion(cs.GenesisForkVersion())
+				genPayloadHeader := types.NewEmptyExecutionPayloadHeader()
 
 				_, err = sp.InitializeBeaconStateFromEth1(
 					st,

consensus-types/types/errors.go

@@ -28,12 +28,9 @@ var (
 	ErrDepositMessage = errors.New("invalid deposit message")
 
 	// ErrInvalidWithdrawalCredentials is an error for when the.
-	ErrInvalidWithdrawalCredentials = errors.New(
-		"invalid withdrawal credentials",
-	)
+	ErrInvalidWithdrawalCredentials = errors.New("invalid withdrawal credentials")
 
-	// ErrForkVersionNotSupported is an error for when the fork
-	// version is not supported.
+	// ErrForkVersionNotSupported is an error for when the fork version is not supported.
 	ErrForkVersionNotSupported = errors.New("fork version not supported")
 
 	// ErrNilValue is an error for when a getter returns nil on a value

consensus-types/types/genesis.go

@@ -82,7 +82,7 @@ func (g *Genesis) UnmarshalJSON(
 		return err
 	}
 
-	payloadHeader := NewEmptyExecutionPayloadHeaderWithVersion(g2.ForkVersion)
+	payloadHeader := NewEmptyExecutionPayloadHeader()
 	if err := json.Unmarshal(g2.ExecutionPayloadHeader, payloadHeader); err != nil {
 		return err
 	}
@@ -95,7 +95,7 @@ func (g *Genesis) UnmarshalJSON(
 
 // DefaultGenesis returns the default genesis.
 func DefaultGenesis(v common.Version) *Genesis {
-	defaultHeader, err := DefaultGenesisExecutionPayloadHeader(v)
+	defaultHeader, err := DefaultGenesisExecutionPayloadHeader()
 	if err != nil {
 		panic(err)
 	}
@@ -108,7 +108,7 @@ func DefaultGenesis(v common.Version) *Genesis {
 }
 
 // DefaultGenesisExecutionPayloadHeader returns a default ExecutionPayloadHeader.
-func DefaultGenesisExecutionPayloadHeader(v common.Version) (*ExecutionPayloadHeader, error) {
+func DefaultGenesisExecutionPayloadHeader() (*ExecutionPayloadHeader, error) {
 	stateRoot, err := bytes.ToBytes32(
 		hex.MustToBytes(
 			"0x12965ab9cbe2d2203f61d23636eb7e998f167cb79d02e452f532535641e35bcc",
@@ -135,7 +135,6 @@ func DefaultGenesisExecutionPayloadHeader(v common.Version) (*ExecutionPayloadHe
 	}
 
 	return &ExecutionPayloadHeader{
-		Versionable:   NewVersionable(v),
 		ParentHash:    common.ExecutionHash{},
 		FeeRecipient:  common.ExecutionAddress{},
 		StateRoot:     stateRoot,

consensus-types/types/genesis_test.go

@@ -70,11 +70,9 @@ func TestDefaultGenesis(t *testing.T) {
 
 func TestDefaultGenesisExecutionPayloadHeader(t *testing.T) {
 	t.Parallel()
-	runForAllSupportedVersions(t, func(t *testing.T, v common.Version) {
-		header, err := types.DefaultGenesisExecutionPayloadHeader(v)
-		require.NoError(t, err)
-		require.NotNil(t, header)
-	})
+	header, err := types.DefaultGenesisExecutionPayloadHeader()
+	require.NoError(t, err)
+	require.NotNil(t, header)
 }
 
 func TestGenesisGetForkVersion(t *testing.T) {

consensus-types/types/payload.go

@@ -577,7 +577,6 @@ func (p *ExecutionPayload) ToHeader() (*ExecutionPayloadHeader, error) {
 	switch p.GetForkVersion() {
 	case version.Deneb(), version.Deneb1(), version.Electra():
 		return &ExecutionPayloadHeader{
-			Versionable:      p.Versionable,
 			ParentHash:       p.GetParentHash(),
 			FeeRecipient:     p.GetFeeRecipient(),
 			StateRoot:        p.GetStateRoot(),
@@ -597,6 +596,6 @@ func (p *ExecutionPayload) ToHeader() (*ExecutionPayloadHeader, error) {
 			ExcessBlobGas:    p.GetExcessBlobGas(),
 		}, nil
 	default:
-		return nil, errors.New("unknown fork version")
+		return nil, ErrForkVersionNotSupported
 	}
 }

consensus-types/types/payload_header.go

@@ -36,22 +36,12 @@ const ExecutionPayloadHeaderStaticSize uint32 = 584
 
 // Compile-time assertions to ensure ExecutionPayloadHeader implements necessary interfaces.
 var (
-	_ ssz.DynamicObject                            = (*ExecutionPayloadHeader)(nil)
-	_ constraints.SSZVersionedMarshallableRootable = (*ExecutionPayloadHeader)(nil)
+	_ ssz.DynamicObject                   = (*ExecutionPayloadHeader)(nil)
+	_ constraints.SSZMarshallableRootable = (*ExecutionPayloadHeader)(nil)
 )
 
 // ExecutionPayloadHeader represents the payload header of an execution block.
 type ExecutionPayloadHeader struct {
-	// NOTE: This version is not required but left in for backwards compatibility.
-	//
-	// A recommended alternative to `GetForkVersion()` on this struct would be to use the chain
-	// spec's `ActiveForkVersionForTimestamp()` on the value of `GetTimestamp()`.
-	//
-	// This version should still be set to the correct value to avoid potential inconsistencies.
-	constraints.Versionable
-
-	// Contents
-	//
 	// ParentHash is the hash of the parent block.
 	ParentHash common.ExecutionHash `json:"parentHash"`
 	// FeeRecipient is the address of the fee recipient.
@@ -88,9 +78,9 @@ type ExecutionPayloadHeader struct {
 	ExcessBlobGas math.U64 `json:"excessBlobGas"`
 }
 
-func NewEmptyExecutionPayloadHeaderWithVersion(version common.Version) *ExecutionPayloadHeader {
+// NewEmptyExecutionPayloadHeader creates a new empty ExecutionPayloadHeader.
+func NewEmptyExecutionPayloadHeader() *ExecutionPayloadHeader {
 	return &ExecutionPayloadHeader{
-		Versionable:   NewVersionable(version),
 		BaseFeePerGas: &math.U256{},
 	}
 }