Implement process exec payload

testing/spectest/mainnet/BUILD.bazel

@@ -200,6 +200,7 @@ go_test(
         "fulu__sanity__blocks_test.go",
         "fulu__sanity__slots_test.go",
         "fulu__ssz_static__ssz_static_test.go",
+        "gloas__operations__execution_payload_test.go",
         "gloas__ssz_static__ssz_static_test.go",
         "phase0__epoch_processing__effective_balance_updates_test.go",
         "phase0__epoch_processing__epoch_processing_test.go",
@@ -278,6 +279,7 @@ go_test(
         "//testing/spectest/shared/fulu/rewards:go_default_library",
         "//testing/spectest/shared/fulu/sanity:go_default_library",
         "//testing/spectest/shared/fulu/ssz_static:go_default_library",
+        "//testing/spectest/shared/gloas/operations:go_default_library",
         "//testing/spectest/shared/gloas/ssz_static:go_default_library",
         "//testing/spectest/shared/phase0/epoch_processing:go_default_library",
         "//testing/spectest/shared/phase0/finality:go_default_library",

testing/spectest/mainnet/gloas__operations__execution_payload_test.go

@@ -0,0 +1,11 @@
+package mainnet
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations"
+)
+
+func TestMainnet_Gloas_Operations_ExecutionPayloadEnvelope(t *testing.T) {
+	operations.RunExecutionPayloadTest(t, "mainnet")
+}

testing/spectest/shared/gloas/operations/BUILD.bazel

@@ -0,0 +1,29 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "execution_payload.go",
+        "helpers.go",
+    ],
+    importpath = "github.com/OffchainLabs/prysm/v7/testing/spectest/shared/gloas/operations",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/gloas:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/spectest/utils:go_default_library",
+        "//testing/util:go_default_library",
+        "@com_github_golang_snappy//:go_default_library",
+        "@com_github_google_go_cmp//cmp:go_default_library",
+        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_google_protobuf//testing/protocmp:go_default_library",
+    ],
+)

testing/spectest/shared/gloas/operations/execution_payload.go

@@ -0,0 +1,119 @@
+package operations
+
+import (
+	"context"
+	"os"
+	"path"
+	"strings"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
+	"github.com/OffchainLabs/prysm/v7/testing/require"
+	"github.com/OffchainLabs/prysm/v7/testing/spectest/utils"
+	"github.com/OffchainLabs/prysm/v7/testing/util"
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/golang/snappy"
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/testing/protocmp"
+)
+
+type ExecutionConfig struct {
+	Valid bool `json:"execution_valid"`
+}
+
+func sszToSignedExecutionPayloadEnvelope(b []byte) (interfaces.ROSignedExecutionPayloadEnvelope, error) {
+	envelope := &enginev1.SignedExecutionPayloadEnvelope{}
+	if err := envelope.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return blocks.WrappedROSignedExecutionPayloadEnvelope(envelope)
+}
+
+func RunExecutionPayloadTest(t *testing.T, config string) {
+	require.NoError(t, utils.SetConfig(t, config))
+	testFolders, testsFolderPath := utils.TestFolders(t, config, "gloas", "operations/execution_payload/pyspec_tests")
+	if len(testFolders) == 0 {
+		t.Fatalf("No test folders found for %s/%s/%s", config, "gloas", "operations/execution_payload/pyspec_tests")
+	}
+	for _, folder := range testFolders {
+		t.Run(folder.Name(), func(t *testing.T) {
+			helpers.ClearCache()
+
+			// Check if signed_envelope.ssz_snappy exists, skip if not
+			_, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy"))
+			if err != nil && strings.Contains(err.Error(), "could not locate file") {
+				t.Skipf("Skipping test %s: signed_envelope.ssz_snappy not found", folder.Name())
+				return
+			}
+
+			// Read the signed execution payload envelope
+			envelopeFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "signed_envelope.ssz_snappy")
+			require.NoError(t, err)
+			envelopeSSZ, err := snappy.Decode(nil /* dst */, envelopeFile)
+			require.NoError(t, err, "Failed to decompress envelope")
+			signedEnvelope, err := sszToSignedExecutionPayloadEnvelope(envelopeSSZ)
+			require.NoError(t, err, "Failed to unmarshal signed envelope")
+
+			preBeaconStateFile, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "pre.ssz_snappy")
+			require.NoError(t, err)
+			preBeaconStateSSZ, err := snappy.Decode(nil /* dst */, preBeaconStateFile)
+			require.NoError(t, err, "Failed to decompress")
+			preBeaconState, err := sszToState(preBeaconStateSSZ)
+			require.NoError(t, err)
+
+			postSSZFilepath, err := bazel.Runfile(path.Join(testsFolderPath, folder.Name(), "post.ssz_snappy"))
+			postSSZExists := true
+			if err != nil && strings.Contains(err.Error(), "could not locate file") {
+				postSSZExists = false
+			} else {
+				require.NoError(t, err)
+			}
+
+			file, err := util.BazelFileBytes(testsFolderPath, folder.Name(), "execution.yaml")
+			require.NoError(t, err)
+			config := &ExecutionConfig{}
+			require.NoError(t, utils.UnmarshalYaml(file, config), "Failed to Unmarshal")
+			if !config.Valid {
+				t.Skip("Skipping invalid execution engine test as it's never supported")
+			}
+
+			err = gloas.ProcessExecutionPayload(context.Background(), preBeaconState, signedEnvelope)
+			if postSSZExists {
+				require.NoError(t, err)
+				comparePostState(t, postSSZFilepath, preBeaconState)
+			} else if config.Valid {
+				// Note: This doesn't test anything worthwhile. It essentially tests
+				// that *any* error has occurred, not any specific error.
+				if err == nil {
+					t.Fatal("Did not fail when expected")
+				}
+				t.Logf("Expected failure; failure reason = %v", err)
+				return
+			}
+		})
+	}
+}
+
+func comparePostState(t *testing.T, postSSZFilepath string, want state.BeaconState) {
+	postBeaconStateFile, err := os.ReadFile(postSSZFilepath) // #nosec G304
+	require.NoError(t, err)
+	postBeaconStateSSZ, err := snappy.Decode(nil /* dst */, postBeaconStateFile)
+	require.NoError(t, err, "Failed to decompress")
+	postBeaconState, err := sszToState(postBeaconStateSSZ)
+	require.NoError(t, err)
+	postBeaconStatePb, ok := postBeaconState.ToProtoUnsafe().(proto.Message)
+	require.Equal(t, true, ok, "post beacon state did not return a proto.Message")
+	pbState, ok := want.ToProtoUnsafe().(proto.Message)
+	require.Equal(t, true, ok, "beacon state did not return a proto.Message")
+
+	if !proto.Equal(postBeaconStatePb, pbState) {
+		diff := cmp.Diff(pbState, postBeaconStatePb, protocmp.Transform())
+		t.Fatalf("Post state does not match expected state, diff: %s", diff)
+	}
+}

testing/spectest/shared/gloas/operations/helpers.go

@@ -0,0 +1,15 @@
+package operations
+
+import (
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+)
+
+func sszToState(b []byte) (state.BeaconState, error) {
+	base := &ethpb.BeaconStateGloas{}
+	if err := base.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return state_native.InitializeFromProtoGloas(base)
+}