simulators/eth2/engine: Add test cases

Author: marioevz

simulators/eth2/engine/engineapi.go

@@ -1,14 +1,189 @@
 package main
 
 import (
+	"context"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"math/big"
+	"net"
+	"net/http"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/hive/hivesim"
+	"github.com/golang-jwt/jwt/v4"
 )
 
+// https://github.com/ethereum/execution-apis/blob/v1.0.0-alpha.7/src/engine/specification.md
+var EthPortHTTP = 8545
+var EnginePortHTTP = 8551
+
+// EngineClient wrapper for Ethereum Engine RPC for testing purposes.
+type EngineClient struct {
+	*hivesim.T
+	*hivesim.Client
+	c                       *rpc.Client
+	Eth                     *ethclient.Client
+	cEth                    *rpc.Client
+	IP                      net.IP
+	TerminalTotalDifficulty *big.Int
+
+	// This holds most recent context created by the Ctx method.
+	// Every time Ctx is called, it creates a new context with the default
+	// timeout and cancels the previous one.
+	lastCtx    context.Context
+	lastCancel context.CancelFunc
+}
+
+// NewClient creates a engine client that uses the given RPC client.
+func NewEngineClient(t *hivesim.T, userRPCAddress string, engineRPCAddress string, ttd *big.Int) *EngineClient {
+	client := &http.Client{}
+	// Prepare HTTP Client
+	rpcHttpClient, _ := rpc.DialHTTPWithClient(engineRPCAddress, client)
+
+	// Prepare ETH Client
+	client = &http.Client{}
+
+	rpcClient, _ := rpc.DialHTTPWithClient(userRPCAddress, client)
+	eth := ethclient.NewClient(rpcClient)
+	return &EngineClient{
+		T:                       t,
+		c:                       rpcHttpClient,
+		Eth:                     eth,
+		cEth:                    rpcClient,
+		TerminalTotalDifficulty: ttd,
+		lastCtx:                 nil,
+		lastCancel:              nil,
+	}
+}
+
+func (ec *EngineClient) Close() {
+	ec.c.Close()
+	ec.Eth.Close()
+	if ec.lastCtx != nil {
+		ec.lastCancel()
+	}
+}
+
+func (ec *EngineClient) Ctx() context.Context {
+	if ec.lastCtx != nil {
+		ec.lastCancel()
+	}
+	ec.lastCtx, ec.lastCancel = context.WithTimeout(context.Background(), 10*time.Second)
+	return ec.lastCtx
+}
+
+// Helper structs to fetch the TotalDifficulty
+type TD struct {
+	TotalDifficulty *hexutil.Big `json:"totalDifficulty"`
+}
+type TotalDifficultyHeader struct {
+	types.Header
+	TD
+}
+
+func (tdh *TotalDifficultyHeader) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &tdh.Header); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &tdh.TD); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (ec *EngineClient) checkTTD() (*types.Header, bool) {
+	var td *TotalDifficultyHeader
+	if err := ec.cEth.CallContext(ec.Ctx(), &td, "eth_getBlockByNumber", "latest", false); err != nil {
+		panic(err)
+	}
+	if td.TotalDifficulty.ToInt().Cmp(ec.TerminalTotalDifficulty) >= 0 {
+		return &td.Header, true
+	}
+	return nil, false
+}
+
+// Engine API Types
+type PayloadStatusV1 struct {
+	Status          PayloadStatus `json:"status"`
+	LatestValidHash *common.Hash  `json:"latestValidHash"`
+	ValidationError *string       `json:"validationError"`
+}
+type ForkChoiceResponse struct {
+	PayloadStatus PayloadStatusV1 `json:"payloadStatus"`
+	PayloadID     *PayloadID      `json:"payloadId"`
+}
+
+type PayloadStatus int
+
+const (
+	Unknown PayloadStatus = iota
+	Valid
+	Invalid
+	Accepted
+	Syncing
+	InvalidBlockHash
+)
+
+var PayloadStatuses = map[PayloadStatus]string{
+	Valid:            "VALID",
+	Invalid:          "INVALID",
+	Accepted:         "ACCEPTED",
+	Syncing:          "SYNCING",
+	InvalidBlockHash: "INVALID_BLOCK_HASH",
+}
+
+func (b PayloadStatus) String() string {
+	str, ok := PayloadStatuses[b]
+	if !ok {
+		return "UNKNOWN"
+	}
+	return str
+}
+
+func (b PayloadStatus) MarshalText() ([]byte, error) {
+	str, ok := PayloadStatuses[b]
+	if !ok {
+		return nil, fmt.Errorf("invalid payload status")
+	}
+	return []byte(str), nil
+}
+
+func (b *PayloadStatus) UnmarshalText(input []byte) error {
+	s := string(input)
+	for p, status := range PayloadStatuses {
+		if status == s {
+			*b = p
+			return nil
+		}
+	}
+	return fmt.Errorf("invalid payload status: %s", s)
+}
+
+type PayloadID [8]byte
+
+func (b PayloadID) MarshalText() ([]byte, error) {
+	return hexutil.Bytes(b[:]).MarshalText()
+}
+func (b *PayloadID) UnmarshalText(input []byte) error {
+	err := hexutil.UnmarshalFixedText("PayloadID", input, b[:])
+	if err != nil {
+		return fmt.Errorf("invalid payload id %q: %w", input, err)
+	}
+	return nil
+}
+
+type ForkchoiceStateV1 struct {
+	HeadBlockHash      common.Hash `json:"headBlockHash"`
+	SafeBlockHash      common.Hash `json:"safeBlockHash"`
+	FinalizedBlockHash common.Hash `json:"finalizedBlockHash"`
+}
+
 //go:generate go run github.com/fjl/gencodec -type ExecutableDataV1 -field-override executableDataMarshaling -out gen_ed.go
 // ExecutableDataV1 structure described at https://github.com/ethereum/execution-apis/src/engine/specification.md
 type ExecutableDataV1 struct {
@@ -40,6 +215,74 @@ type executableDataMarshaling struct {
 	Transactions  []hexutil.Bytes
 }
 
+//go:generate go run github.com/fjl/gencodec -type PayloadAttributesV1 -field-override payloadAttributesMarshaling -out gen_blockparams.go
+// PayloadAttributesV1 structure described at https://github.com/ethereum/execution-apis/pull/74
+type PayloadAttributesV1 struct {
+	Timestamp             uint64         `json:"timestamp"              gencodec:"required"`
+	PrevRandao            common.Hash    `json:"prevRandao"             gencodec:"required"`
+	SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient"  gencodec:"required"`
+}
+
+// JSON type overrides for PayloadAttributesV1.
+type payloadAttributesMarshaling struct {
+	Timestamp hexutil.Uint64
+}
+
+// JWT Tokens
+func GetNewToken(jwtSecretBytes []byte, iat time.Time) (string, error) {
+	newToken := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"iat": iat.Unix(),
+	})
+	tokenString, err := newToken.SignedString(jwtSecretBytes)
+	if err != nil {
+		return "", err
+	}
+	return tokenString, nil
+}
+
+func (ec *EngineClient) PrepareAuthCallToken(jwtSecretBytes []byte, iat time.Time) error {
+	newTokenString, err := GetNewToken(jwtSecretBytes, iat)
+	if err != nil {
+		return err
+	}
+	ec.c.SetHeader("Authorization", fmt.Sprintf("Bearer %s", newTokenString))
+	return nil
+}
+
+func (ec *EngineClient) PrepareDefaultAuthCallToken() error {
+	secret, _ := hex.DecodeString("7365637265747365637265747365637265747365637265747365637265747365")
+	ec.PrepareAuthCallToken(secret, time.Now())
+	return nil
+}
+
+// Engine API Call Methods
+func (ec *EngineClient) EngineForkchoiceUpdatedV1(fcState *ForkchoiceStateV1, pAttributes *PayloadAttributesV1) (ForkChoiceResponse, error) {
+	var result ForkChoiceResponse
+	if err := ec.PrepareDefaultAuthCallToken(); err != nil {
+		return result, err
+	}
+	err := ec.c.CallContext(ec.Ctx(), &result, "engine_forkchoiceUpdatedV1", fcState, pAttributes)
+	return result, err
+}
+
+func (ec *EngineClient) EngineGetPayloadV1(payloadId *PayloadID) (ExecutableDataV1, error) {
+	var result ExecutableDataV1
+	if err := ec.PrepareDefaultAuthCallToken(); err != nil {
+		return result, err
+	}
+	err := ec.c.CallContext(ec.Ctx(), &result, "engine_getPayloadV1", payloadId)
+	return result, err
+}
+
+func (ec *EngineClient) EngineNewPayloadV1(payload *ExecutableDataV1) (PayloadStatusV1, error) {
+	var result PayloadStatusV1
+	if err := ec.PrepareDefaultAuthCallToken(); err != nil {
+		return result, err
+	}
+	err := ec.c.CallContext(ec.Ctx(), &result, "engine_newPayloadV1", payload)
+	return result, err
+}
+
 // Json helpers
 // A value of this type can a JSON-RPC request, notification, successful response or
 // error response. Which one it is depends on the fields.
@@ -65,7 +308,7 @@ type jsonrpcMessage struct {
 	Result  json.RawMessage `json:"result,omitempty"`
 }
 
-func UnmarshalFromJsonRPC(b []byte, result interface{}) error {
+func UnmarshalFromJsonRPCResponse(b []byte, result interface{}) error {
 	var rpcMessage jsonrpcMessage
 	err := json.Unmarshal(b, &rpcMessage)
 	if err != nil {
@@ -77,3 +320,16 @@ func UnmarshalFromJsonRPC(b []byte, result interface{}) error {
 	err = json.Unmarshal(rpcMessage.Result, &result)
 	return nil
 }
+
+func UnmarshalFromJsonRPCRequest(b []byte, params ...interface{}) error {
+	var rpcMessage jsonrpcMessage
+	err := json.Unmarshal(b, &rpcMessage)
+	if err != nil {
+		return err
+	}
+	if rpcMessage.Error != nil {
+		return rpcMessage.Error
+	}
+	err = json.Unmarshal(rpcMessage.Params, &params)
+	return nil
+}

simulators/eth2/engine/gen_blockparams.go

@@ -70,3 +70,5 @@ require (
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 )
+
+replace github.com/rauljordan/engine-proxy => github.com/marioevz/engine-proxy v0.0.0-20220617181151-e8661eb39eea

simulators/eth2/engine/go.mod

@@ -272,6 +272,8 @@ github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/marioevz/engine-proxy v0.0.0-20220617181151-e8661eb39eea h1:9ahHMPkNvYf9Nn3+U072ZKMDm05gaXfRESAmwP07Q+M=
+github.com/marioevz/engine-proxy v0.0.0-20220617181151-e8661eb39eea/go.mod h1:9OVXfWYnIV+wj1/SqfdREmE5mzN/OANAgdOJRtFtvpo=
 github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=