engine_client.go 6.47 KB
Newer Older
1 2 3 4 5 6 7
package sources

import (
	"context"
	"fmt"
	"time"

8
	"github.com/ethereum/go-ethereum/common"
9
	"github.com/ethereum/go-ethereum/eth/catalyst"
10
	"github.com/ethereum/go-ethereum/log"
11
	"github.com/ethereum/go-ethereum/params"
12
	"github.com/ethereum/go-ethereum/rpc"
13

14
	"github.com/ethereum-optimism/optimism/op-node/rollup"
Sabnock01's avatar
Sabnock01 committed
15
	"github.com/ethereum-optimism/optimism/op-service/client"
16
	"github.com/ethereum-optimism/optimism/op-service/eth"
Sabnock01's avatar
Sabnock01 committed
17
	"github.com/ethereum-optimism/optimism/op-service/sources/caching"
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
)

type EngineClientConfig struct {
	L2ClientConfig
}

func EngineClientDefaultConfig(config *rollup.Config) *EngineClientConfig {
	return &EngineClientConfig{
		// engine is trusted, no need to recompute responses etc.
		L2ClientConfig: *L2ClientDefaultConfig(config, true),
	}
}

// EngineClient extends L2Client with engine API bindings.
type EngineClient struct {
	*L2Client
34
	*EngineAPIClient
35 36 37 38 39 40 41 42
}

func NewEngineClient(client client.RPC, log log.Logger, metrics caching.Metrics, config *EngineClientConfig) (*EngineClient, error) {
	l2Client, err := NewL2Client(client, log, metrics, &config.L2ClientConfig)
	if err != nil {
		return nil, err
	}

43 44
	engineAPIClient := NewEngineAPIClient(client, log, config.RollupCfg)

45
	return &EngineClient{
46 47
		L2Client:        l2Client,
		EngineAPIClient: engineAPIClient,
48 49 50
	}, nil
}

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
// EngineAPIClient is an RPC client for the Engine API functions.
type EngineAPIClient struct {
	RPC client.RPC
	log log.Logger
	evp EngineVersionProvider
}

type EngineVersionProvider interface {
	ForkchoiceUpdatedVersion(attr *eth.PayloadAttributes) eth.EngineAPIMethod
	NewPayloadVersion(timestamp uint64) eth.EngineAPIMethod
	GetPayloadVersion(timestamp uint64) eth.EngineAPIMethod
}

func NewEngineAPIClient(rpc client.RPC, l log.Logger, evp EngineVersionProvider) *EngineAPIClient {
	return &EngineAPIClient{
		RPC: rpc,
		log: l,
		evp: evp,
	}
}

// EngineVersionProvider returns the underlying engine version provider used for
// resolving the correct Engine API versions.
func (s *EngineAPIClient) EngineVersionProvider() EngineVersionProvider { return s.evp }

76 77 78
// ForkchoiceUpdate updates the forkchoice on the execution client. If attributes is not nil, the engine client will also begin building a block
// based on attributes after the new head block and return the payload ID.
//
79 80 81 82
// The RPC may return three types of errors:
// 1. Processing error: ForkchoiceUpdatedResult.PayloadStatusV1.ValidationError or other non-success PayloadStatusV1,
// 2. `error` as eth.InputError: the forkchoice state or attributes are not valid.
// 3. Other types of `error`: temporary RPC errors, like timeouts.
83
func (s *EngineAPIClient) ForkchoiceUpdate(ctx context.Context, fc *eth.ForkchoiceState, attributes *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error) {
84 85 86
	llog := s.log.New("state", fc)       // local logger
	tlog := llog.New("attr", attributes) // trace logger
	tlog.Trace("Sharing forkchoice-updated signal")
87 88 89
	fcCtx, cancel := context.WithTimeout(ctx, time.Second*5)
	defer cancel()
	var result eth.ForkchoiceUpdatedResult
90 91
	method := s.evp.ForkchoiceUpdatedVersion(attributes)
	err := s.RPC.CallContext(fcCtx, &result, string(method), fc, attributes)
92
	if err == nil {
93
		tlog.Trace("Shared forkchoice-updated signal")
94
		if attributes != nil { // block building is optional, we only get a payload ID if we are building a block
95
			tlog.Trace("Received payload id", "payloadId", result.PayloadID)
96 97 98
		}
		return &result, nil
	} else {
99
		llog.Warn("Failed to share forkchoice-updated signal", "err", err)
100 101
		if rpcErr, ok := err.(rpc.Error); ok {
			code := eth.ErrorCode(rpcErr.ErrorCode())
102 103 104 105 106 107 108 109 110
			switch code {
			case eth.InvalidForkchoiceState, eth.InvalidPayloadAttributes:
				return nil, eth.InputError{
					Inner: err,
					Code:  code,
				}
			default:
				return nil, fmt.Errorf("unrecognized rpc error: %w", err)
			}
111 112 113 114 115 116 117 118
		}
		return nil, err
	}
}

// NewPayload executes a full block on the execution engine.
// This returns a PayloadStatusV1 which encodes any validation/processing error,
// and this type of error is kept separate from the returned `error` used for RPC errors, like timeouts.
119
func (s *EngineAPIClient) NewPayload(ctx context.Context, payload *eth.ExecutionPayload, parentBeaconBlockRoot *common.Hash) (*eth.PayloadStatusV1, error) {
120 121 122 123 124 125
	e := s.log.New("block_hash", payload.BlockHash)
	e.Trace("sending payload for execution")

	execCtx, cancel := context.WithTimeout(ctx, time.Second*5)
	defer cancel()
	var result eth.PayloadStatusV1
126 127

	var err error
128
	switch method := s.evp.NewPayloadVersion(uint64(payload.Timestamp)); method {
129
	case eth.NewPayloadV3:
130
		err = s.RPC.CallContext(execCtx, &result, string(method), payload, []common.Hash{}, parentBeaconBlockRoot)
131
	case eth.NewPayloadV2:
132
		err = s.RPC.CallContext(execCtx, &result, string(method), payload)
133 134
	default:
		return nil, fmt.Errorf("unsupported NewPayload version: %s", method)
135 136
	}

137 138 139 140 141 142 143 144
	e.Trace("Received payload execution result", "status", result.Status, "latestValidHash", result.LatestValidHash, "message", result.ValidationError)
	if err != nil {
		e.Error("Payload execution failed", "err", err)
		return nil, fmt.Errorf("failed to execute payload: %w", err)
	}
	return &result, nil
}

145 146 147 148
// GetPayload gets the execution payload associated with the PayloadId.
// There may be two types of error:
// 1. `error` as eth.InputError: the payload ID may be unknown
// 2. Other types of `error`: temporary RPC errors, like timeouts.
149
func (s *EngineAPIClient) GetPayload(ctx context.Context, payloadInfo eth.PayloadInfo) (*eth.ExecutionPayloadEnvelope, error) {
150
	e := s.log.New("payload_id", payloadInfo.ID)
151
	e.Trace("getting payload")
152
	var result eth.ExecutionPayloadEnvelope
153 154
	method := s.evp.GetPayloadVersion(payloadInfo.Timestamp)
	err := s.RPC.CallContext(ctx, &result, string(method), payloadInfo.ID)
155
	if err != nil {
156
		e.Warn("Failed to get payload", "payload_id", payloadInfo.ID, "err", err)
157 158
		if rpcErr, ok := err.(rpc.Error); ok {
			code := eth.ErrorCode(rpcErr.ErrorCode())
159 160 161 162 163 164 165 166
			switch code {
			case eth.UnknownPayload:
				return nil, eth.InputError{
					Inner: err,
					Code:  code,
				}
			default:
				return nil, fmt.Errorf("unrecognized rpc error: %w", err)
167 168 169 170 171
			}
		}
		return nil, err
	}
	e.Trace("Received payload")
172
	return &result, nil
173
}
174

175
func (s *EngineAPIClient) SignalSuperchainV1(ctx context.Context, recommended, required params.ProtocolVersion) (params.ProtocolVersion, error) {
176
	var result params.ProtocolVersion
177
	err := s.RPC.CallContext(ctx, &result, "engine_signalSuperchainV1", &catalyst.SuperchainSignal{
178 179 180 181 182
		Recommended: recommended,
		Required:    required,
	})
	return result, err
}