fix helpers

Author: tac0turtle

execution/evm/test/execution_test.go

@@ -21,8 +21,8 @@ import (
 
 const (
 	CHAIN_ID          = "1234"
-	GENESIS_HASH      = "0x2b8bbb1ea1e04f9c9809b4b278a8687806edc061a356c7dbc491930d8e922503"
-	GENESIS_STATEROOT = "0x05e9954443da80d86f2104e56ffdfd98fe21988730684360104865b3dc8191b4"
+	GENESIS_HASH      = "0x6699a4ef6e7b76499c6cd68443455a3584e505b1da43cf82e6efaef41f5e1d8a"
+	GENESIS_STATEROOT = "0x0373244015ce5fa583ed6e575b7a22c39a542233a62d2bd47c37fd1a2b035366"
 	TEST_PRIVATE_KEY  = "cece4f25ac74deb1468965160c7185e07dff413f23fcadb611b05ca37ab0a52e"
 	TEST_TO_ADDRESS   = "0x944fDcD1c868E3cC566C78023CcB38A32cDA836E"
 )

execution/evm/test/test_helpers.go

@@ -5,6 +5,7 @@ package test
 import (
 	"context"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	mathrand "math/rand"
 	"net/http"
@@ -79,51 +80,115 @@ func SetupTestRethNode(t testing.TB, client types.TastoraDockerClient, networkID
 // waitForRethContainer waits for the Reth container to be ready by polling the provided endpoints with JWT authentication.
 func waitForRethContainer(t testing.TB, jwtSecret, ethURL, engineURL string) error {
 	t.Helper()
-	client := &http.Client{Timeout: 100 * time.Millisecond}
+
+	secret, err := decodeSecret(jwtSecret)
+	if err != nil {
+		return err
+	}
+	authToken, err := getAuthToken(secret)
+	if err != nil {
+		return err
+	}
+
+	client := &http.Client{Timeout: 500 * time.Millisecond}
 	timer := time.NewTimer(30 * time.Second)
 	defer timer.Stop()
+	var lastErr error
 	for {
 		select {
 		case <-timer.C:
+			if lastErr != nil {
+				return fmt.Errorf("timeout waiting for reth container to be ready: %w", lastErr)
+			}
 			return fmt.Errorf("timeout waiting for reth container to be ready")
 		default:
-			rpcReq := strings.NewReader(`{"jsonrpc":"2.0","method":"net_version","params":[],"id":1}`)
-			resp, err := client.Post(ethURL, "application/json", rpcReq)
+			genesisHash, err := getGenesisHash(client, ethURL)
+			if err == nil {
+				err = waitForEngineForkchoice(client, engineURL, authToken, genesisHash)
+			}
 			if err == nil {
-				if err := resp.Body.Close(); err != nil {
-					return fmt.Errorf("failed to close response body: %w", err)
-				}
-				if resp.StatusCode == http.StatusOK {
-					req, err := http.NewRequest("POST", engineURL, strings.NewReader(`{"jsonrpc":"2.0","method":"engine_getClientVersionV1","params":[],"id":1}`))
-					if err != nil {
-						return err
-					}
-					req.Header.Set("Content-Type", "application/json")
-					secret, err := decodeSecret(jwtSecret)
-					if err != nil {
-						return err
-					}
-					authToken, err := getAuthToken(secret)
-					if err != nil {
-						return err
-					}
-					req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", authToken))
-					resp, err := client.Do(req)
-					if err == nil {
-						if err := resp.Body.Close(); err != nil {
-							return fmt.Errorf("failed to close response body: %w", err)
-						}
-						if resp.StatusCode == http.StatusOK {
-							return nil
-						}
-					}
-				}
+				return nil
 			}
+			lastErr = err
 			time.Sleep(100 * time.Millisecond)
 		}
 	}
 }
 
+type jsonRPCError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+func getGenesisHash(client *http.Client, ethURL string) (string, error) {
+	rpcReq := strings.NewReader(`{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["0x0",false],"id":1}`)
+	resp, err := client.Post(ethURL, "application/json", rpcReq)
+	if err != nil {
+		return "", err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("eth endpoint returned status %d", resp.StatusCode)
+	}
+
+	var rpcResp struct {
+		Result struct {
+			Hash string `json:"hash"`
+		} `json:"result"`
+		Error *jsonRPCError `json:"error,omitempty"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&rpcResp); err != nil {
+		return "", fmt.Errorf("decode genesis block response: %w", err)
+	}
+	if rpcResp.Error != nil {
+		return "", fmt.Errorf("eth_getBlockByNumber failed: %s", rpcResp.Error.Message)
+	}
+	if rpcResp.Result.Hash == "" {
+		return "", fmt.Errorf("eth_getBlockByNumber returned empty genesis hash")
+	}
+	return rpcResp.Result.Hash, nil
+}
+
+func waitForEngineForkchoice(client *http.Client, engineURL, authToken, genesisHash string) error {
+	body := fmt.Sprintf(`{"jsonrpc":"2.0","method":"engine_forkchoiceUpdatedV3","params":[{"headBlockHash":%q,"safeBlockHash":%q,"finalizedBlockHash":%q},null],"id":1}`, genesisHash, genesisHash, genesisHash)
+	req, err := http.NewRequest("POST", engineURL, strings.NewReader(body))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", authToken))
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("engine endpoint returned status %d", resp.StatusCode)
+	}
+
+	var rpcResp struct {
+		Result struct {
+			PayloadStatus struct {
+				Status string `json:"status"`
+			} `json:"payloadStatus"`
+		} `json:"result"`
+		Error *jsonRPCError `json:"error,omitempty"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&rpcResp); err != nil {
+		return fmt.Errorf("decode engine forkchoice response: %w", err)
+	}
+	if rpcResp.Error != nil {
+		return fmt.Errorf("engine_forkchoiceUpdatedV3 failed: %s", rpcResp.Error.Message)
+	}
+	if rpcResp.Result.PayloadStatus.Status != "VALID" {
+		return fmt.Errorf("engine forkchoice status %s", rpcResp.Result.PayloadStatus.Status)
+	}
+	return nil
+}
+
 // decodeSecret decodes a hex-encoded JWT secret string into a byte slice.
 func decodeSecret(jwtSecret string) ([]byte, error) {
 	secret, err := hex.DecodeString(strings.TrimPrefix(jwtSecret, "0x"))