test with pr-266

Author: tac0turtle

execution/evm/engine_payload.go

@@ -45,17 +45,36 @@ func (e *EnginePayloadEnvelope) UnmarshalJSON(input []byte) error {
 		return errors.New("missing required field 'executionPayload' for EnginePayloadEnvelope")
 	}
 
-	var payload engine.ExecutableData
-	if err := json.Unmarshal(dec.ExecutionPayload, &payload); err != nil {
-		return err
-	}
 	var amsterdamProbe struct {
 		SlotNumber      json.RawMessage `json:"slotNumber"`
 		BlockAccessList json.RawMessage `json:"blockAccessList"`
 	}
 	if err := json.Unmarshal(dec.ExecutionPayload, &amsterdamProbe); err != nil {
 		return err
 	}
+
+	// Execution clients disagree on the blockAccessList JSON schema (reth
+	// encodes the raw access-list bytes as a hex string, go-ethereum uses
+	// structured objects). Strip the field before the typed decode so either
+	// shape is accepted; RawExecutionPayload keeps it for passthrough.
+	typedPayload := dec.ExecutionPayload
+	if amsterdamProbe.BlockAccessList != nil {
+		var fields map[string]json.RawMessage
+		if err := json.Unmarshal(dec.ExecutionPayload, &fields); err != nil {
+			return err
+		}
+		delete(fields, "blockAccessList")
+		sanitized, err := json.Marshal(fields)
+		if err != nil {
+			return err
+		}
+		typedPayload = sanitized
+	}
+
+	var payload engine.ExecutableData
+	if err := json.Unmarshal(typedPayload, &payload); err != nil {
+		return err
+	}
 	e.ExecutionPayload = &payload
 	e.RawExecutionPayload = append(e.RawExecutionPayload[:0], dec.ExecutionPayload...)
 	e.rawHasAmsterdamFields = amsterdamProbe.SlotNumber != nil || amsterdamProbe.BlockAccessList != nil

execution/evm/engine_rpc_client_test.go

@@ -104,9 +104,12 @@ const (
 	zeroHashHex = "0x0000000000000000000000000000000000000000000000000000000000000000"
 )
 
-// minimalBlockAccessListJSON is a spec-shaped (EIP-7928) block access list with
-// a single account entry, as returned by engine_getPayloadV6.
-const minimalBlockAccessListJSON = `[{"address": "0x00000000000000000000000000000000000000aa"}]`
+// minimalBlockAccessListJSON matches ev-reth's wire encoding of
+// executionPayload.blockAccessList in engine_getPayloadV6 responses: the
+// encoded access list as a hex string. go-ethereum instead models the field as
+// structured JSON objects; ev-node must accept either shape and pass it
+// through unchanged (see TestEnginePayloadEnvelope_StructuredBlockAccessList).
+const minimalBlockAccessListJSON = `"0x1234"`
 
 func minimalAmsterdamPayloadEnvelopeJSON(t *testing.T) string {
 	t.Helper()
@@ -528,6 +531,28 @@ func TestNewPayload_NilExecutionRequests_EncodedAsEmptyArray(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestEnginePayloadEnvelope_StructuredBlockAccessList(t *testing.T) {
+	structured := strings.Replace(
+		minimalAmsterdamPayloadEnvelopeJSON(t),
+		`"blockAccessList": `+minimalBlockAccessListJSON,
+		`"blockAccessList": [{"address": "0x00000000000000000000000000000000000000aa"}]`,
+		1,
+	)
+
+	var envelope EnginePayloadEnvelope
+	require.NoError(t, json.Unmarshal([]byte(structured), &envelope))
+	require.True(t, envelope.hasAmsterdamFields())
+
+	payload, err := envelope.executionPayloadParam()
+	require.NoError(t, err)
+	raw, ok := payload.(json.RawMessage)
+	require.True(t, ok)
+
+	var fields map[string]json.RawMessage
+	require.NoError(t, json.Unmarshal(raw, &fields))
+	require.JSONEq(t, `[{"address": "0x00000000000000000000000000000000000000aa"}]`, string(fields["blockAccessList"]))
+}
+
 func TestEnginePayloadEnvelope_MarshalJSON_UsesWireFieldNames(t *testing.T) {
 	var envelope EnginePayloadEnvelope
 	require.NoError(t, json.Unmarshal([]byte(minimalAmsterdamPayloadEnvelopeJSON(t)), &envelope))

execution/evm/test/engine_fork_upgrade_test.go

@@ -33,6 +33,12 @@ const (
 	forkCyclePragueTimestamp    = uint64(12)
 	forkCycleOsakaTimestamp     = uint64(24)
 	forkCycleAmsterdamTimestamp = uint64(36)
+
+	// defaultEvRethForkTag pins the ev-reth image built from
+	// https://github.com/evstack/ev-reth/pull/266 (reth 2.3), the first build
+	// with Amsterdam Engine API support. Replace with a release tag once that
+	// PR ships. EV_RETH_IMAGE_REPO/EV_RETH_TAG override this.
+	defaultEvRethForkTag = "pr-266"
 )
 
 // TestEngineAPIForkUpgradeCycleE2E drives ev-node's EngineClient against a real
@@ -41,8 +47,9 @@ const (
 // ev-node, so this verifies the V4 -> V5 -> V6 upgrade path instead of only
 // asserting that blocks are produced.
 //
-// The existing Tastora ev-reth image is used by default. Set EV_RETH_TAG, or set
-// EV_RETH_IMAGE_REPO with optional EV_RETH_TAG, to point at a local or registry image.
+// The ghcr.io/evstack/ev-reth image tagged defaultEvRethForkTag is used by
+// default. Set EV_RETH_TAG, or set EV_RETH_IMAGE_REPO with optional EV_RETH_TAG,
+// to point at a local or registry image.
 func TestEngineAPIForkUpgradeCycleE2E(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping due to short mode")
@@ -136,11 +143,12 @@ func withEngineForkTimes(t testing.TB, osakaTime, amsterdamTime uint64) reth.Gen
 func rethImageOptFromEnv() RethNodeOpt {
 	repo := strings.TrimSpace(os.Getenv("EV_RETH_IMAGE_REPO"))
 	tag := strings.TrimSpace(os.Getenv("EV_RETH_TAG"))
-	if repo == "" && tag == "" {
-		return nil
-	}
 	if tag == "" {
-		tag = "latest"
+		if repo == "" {
+			tag = defaultEvRethForkTag
+		} else {
+			tag = "latest"
+		}
 	}
 	return func(b *reth.NodeBuilder) {
 		if repo != "" {