l2_engine_api.go 21.7 KB
Newer Older
1
package engineapi
2 3 4

import (
	"context"
5 6
	"crypto/sha256"
	"encoding/binary"
7 8
	"errors"
	"fmt"
9
	"math/big"
10 11
	"time"

12
	"github.com/ethereum-optimism/optimism/op-service/eth"
13
	"github.com/ethereum/go-ethereum/beacon/engine"
14
	"github.com/ethereum/go-ethereum/common"
15
	"github.com/ethereum/go-ethereum/consensus"
16
	"github.com/ethereum/go-ethereum/core/state"
17
	"github.com/ethereum/go-ethereum/core/stateless"
18
	"github.com/ethereum/go-ethereum/core/types"
19
	"github.com/ethereum/go-ethereum/core/vm"
20
	"github.com/ethereum/go-ethereum/eth/downloader"
21
	"github.com/ethereum/go-ethereum/log"
22
	"github.com/ethereum/go-ethereum/params"
23
	"github.com/holiman/uint256"
24 25
)

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
type EngineBackend interface {
	CurrentSafeBlock() *types.Header
	CurrentFinalBlock() *types.Header
	GetBlockByHash(hash common.Hash) *types.Block
	GetBlock(hash common.Hash, number uint64) *types.Block
	HasBlockAndState(hash common.Hash, number uint64) bool
	GetCanonicalHash(n uint64) common.Hash

	GetVMConfig() *vm.Config
	Config() *params.ChainConfig
	// Engine retrieves the chain's consensus engine.
	Engine() consensus.Engine

	StateAt(root common.Hash) (*state.StateDB, error)

41
	InsertBlockWithoutSetHead(block *types.Block, makeWitness bool) (*stateless.Witness, error)
42 43 44
	SetCanonical(head *types.Block) (common.Hash, error)
	SetFinalized(header *types.Header)
	SetSafe(header *types.Header)
45 46

	consensus.ChainHeaderReader
47 48
}

49 50 51 52 53
type CachingEngineBackend interface {
	EngineBackend
	AssembleAndInsertBlockWithoutSetHead(processor *BlockProcessor) (*types.Block, error)
}

54 55 56
// L2EngineAPI wraps an engine actor, and implements the RPC backend required to serve the engine API.
// This re-implements some of the Geth API work, but changes the API backend so we can deterministically
// build and control the L2 block contents to reach very specific edge cases as desired for testing.
57 58 59 60
type L2EngineAPI struct {
	log     log.Logger
	backend EngineBackend

61 62 63 64
	// Functionality for snap sync
	remotes    map[common.Hash]*types.Block
	downloader *downloader.Downloader

65
	// L2 block building data
66 67 68 69
	blockProcessor *BlockProcessor
	pendingIndices map[common.Address]uint64 // per account, how many txs from the pool were already included in the block, since the pool is lagging behind block mining.
	l2ForceEmpty   bool                      // when no additional txs may be processed (i.e. when sequencer drift runs out)
	l2TxFailed     []*types.Transaction      // log of failed transactions which could not be included
70 71 72 73

	payloadID engine.PayloadID // ID of payload that is currently being built
}

74
func NewL2EngineAPI(log log.Logger, backend EngineBackend, downloader *downloader.Downloader) *L2EngineAPI {
75
	return &L2EngineAPI{
76 77 78 79
		log:        log,
		backend:    backend,
		remotes:    make(map[common.Hash]*types.Block),
		downloader: downloader,
80 81
	}
}
82 83

var (
84 85
	STATUS_INVALID = &eth.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, PayloadID: nil}
	STATUS_SYNCING = &eth.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}
86 87
)

88
// computePayloadId computes a pseudo-random payloadid, based on the parameters.
89
func computePayloadId(headBlockHash common.Hash, attrs *eth.PayloadAttributes) engine.PayloadID {
90 91 92
	// Hash
	hasher := sha256.New()
	hasher.Write(headBlockHash[:])
93 94 95 96 97 98
	_ = binary.Write(hasher, binary.BigEndian, attrs.Timestamp)
	hasher.Write(attrs.PrevRandao[:])
	hasher.Write(attrs.SuggestedFeeRecipient[:])
	_ = binary.Write(hasher, binary.BigEndian, attrs.NoTxPool)
	_ = binary.Write(hasher, binary.BigEndian, uint64(len(attrs.Transactions)))
	for _, tx := range attrs.Transactions {
99 100 101
		_ = binary.Write(hasher, binary.BigEndian, uint64(len(tx))) // length-prefix to avoid collisions
		hasher.Write(tx)
	}
102
	_ = binary.Write(hasher, binary.BigEndian, *attrs.GasLimit)
103
	var out engine.PayloadID
104 105 106 107
	copy(out[:], hasher.Sum(nil)[:8])
	return out
}

108
func (ea *L2EngineAPI) RemainingBlockGas() uint64 {
109 110 111 112
	if ea.blockProcessor == nil {
		return 0
	}
	return ea.blockProcessor.gasPool.Gas()
113 114 115 116 117 118 119 120 121 122
}

func (ea *L2EngineAPI) ForcedEmpty() bool {
	return ea.l2ForceEmpty
}

func (ea *L2EngineAPI) PendingIndices(from common.Address) uint64 {
	return ea.pendingIndices[from]
}

123
var ErrNotBuildingBlock = errors.New("not currently building a block, cannot include tx from queue")
124 125

func (ea *L2EngineAPI) IncludeTx(tx *types.Transaction, from common.Address) error {
126
	if ea.blockProcessor == nil {
127 128 129 130 131 132 133 134
		return ErrNotBuildingBlock
	}
	if ea.l2ForceEmpty {
		ea.log.Info("Skipping including a transaction because e.L2ForceEmpty is true")
		// t.InvalidAction("cannot include any sequencer txs")
		return nil
	}

135 136 137
	err := ea.blockProcessor.CheckTxWithinGasLimit(tx)
	if err != nil {
		return err
138 139 140
	}

	ea.pendingIndices[from] = ea.pendingIndices[from] + 1 // won't retry the tx
141
	err = ea.blockProcessor.AddTx(tx)
142 143
	if err != nil {
		ea.l2TxFailed = append(ea.l2TxFailed, tx)
144
		return fmt.Errorf("invalid L2 block (tx %d): %w", len(ea.blockProcessor.transactions), err)
145 146 147 148
	}
	return nil
}

149
func (ea *L2EngineAPI) startBlock(parent common.Hash, attrs *eth.PayloadAttributes) error {
150 151
	if ea.blockProcessor != nil {
		ea.log.Warn("started building new block without ending previous block", "previous", ea.blockProcessor.header, "prev_payload_id", ea.payloadID)
152 153
	}

154
	processor, err := NewBlockProcessorFromPayloadAttributes(ea.backend, parent, attrs)
155
	if err != nil {
156
		return err
157
	}
158
	ea.blockProcessor = processor
159
	ea.pendingIndices = make(map[common.Address]uint64)
160 161
	ea.l2ForceEmpty = attrs.NoTxPool
	ea.payloadID = computePayloadId(parent, attrs)
162 163

	// pre-process the deposits
164
	for i, otx := range attrs.Transactions {
165 166
		var tx types.Transaction
		if err := tx.UnmarshalBinary(otx); err != nil {
Joshua Gutow's avatar
Joshua Gutow committed
167
			return fmt.Errorf("transaction %d is not valid: %w", i, err)
168
		}
169
		err := ea.blockProcessor.AddTx(&tx)
170 171 172 173 174 175
		if err != nil {
			ea.l2TxFailed = append(ea.l2TxFailed, &tx)
			return fmt.Errorf("failed to apply deposit transaction to L2 block (tx %d): %w", i, err)
		}
	}
	return nil
176 177 178
}

func (ea *L2EngineAPI) endBlock() (*types.Block, error) {
179
	if ea.blockProcessor == nil {
180 181
		return nil, fmt.Errorf("no block is being built currently (id %s)", ea.payloadID)
	}
182 183
	processor := ea.blockProcessor
	ea.blockProcessor = nil
184

185 186 187 188 189 190 191 192 193 194 195 196
	var block *types.Block
	var err error
	// If the backend supports it, write the newly created block to the database without making it canonical.
	// This avoids needing to reprocess the block if it is sent back via newPayload.
	// The block is not made canonical so if it is never sent back via newPayload worst case it just wastes some storage
	// In the context of the OP Stack derivation, the created block is always immediately imported so it makes sense to
	// optimise.
	if cachingBackend, ok := ea.backend.(CachingEngineBackend); ok {
		block, err = cachingBackend.AssembleAndInsertBlockWithoutSetHead(processor)
	} else {
		block, err = processor.Assemble()
	}
197 198 199
	if err != nil {
		return nil, fmt.Errorf("assemble block: %w", err)
	}
200
	return block, nil
201 202 203
}

func (ea *L2EngineAPI) GetPayloadV1(ctx context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayload, error) {
204 205 206 207 208
	res, err := ea.getPayload(ctx, payloadId)
	if err != nil {
		return nil, err
	}
	return res.ExecutionPayload, nil
209 210 211
}

func (ea *L2EngineAPI) GetPayloadV2(ctx context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayloadEnvelope, error) {
212 213 214 215 216
	return ea.getPayload(ctx, payloadId)
}

func (ea *L2EngineAPI) GetPayloadV3(ctx context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayloadEnvelope, error) {
	return ea.getPayload(ctx, payloadId)
217 218
}

219 220 221 222
func (ea *L2EngineAPI) config() *params.ChainConfig {
	return ea.backend.Config()
}

223
func (ea *L2EngineAPI) ForkchoiceUpdatedV1(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error) {
224 225 226 227 228 229 230 231 232
	if attr != nil {
		if attr.Withdrawals != nil {
			return STATUS_INVALID, engine.InvalidParams.With(errors.New("withdrawals not supported in V1"))
		}
		if ea.config().IsShanghai(ea.config().LondonBlock, uint64(attr.Timestamp)) {
			return STATUS_INVALID, engine.InvalidParams.With(errors.New("forkChoiceUpdateV1 called post-shanghai"))
		}
	}

233 234 235 236
	return ea.forkchoiceUpdated(ctx, state, attr)
}

func (ea *L2EngineAPI) ForkchoiceUpdatedV2(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error) {
237 238 239 240 241 242
	if attr != nil {
		if err := ea.verifyPayloadAttributes(attr); err != nil {
			return STATUS_INVALID, engine.InvalidParams.With(err)
		}
	}

243 244 245
	return ea.forkchoiceUpdated(ctx, state, attr)
}

246 247 248 249 250 251 252 253 254 255 256
// Ported from: https://github.com/ethereum-optimism/op-geth/blob/c50337a60a1309a0f1dca3bf33ed1bb38c46cdd7/eth/catalyst/api.go#L197C1-L205C1
func (ea *L2EngineAPI) ForkchoiceUpdatedV3(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error) {
	if attr != nil {
		if err := ea.verifyPayloadAttributes(attr); err != nil {
			return STATUS_INVALID, engine.InvalidParams.With(err)
		}
	}
	return ea.forkchoiceUpdated(ctx, state, attr)
}

// Ported from: https://github.com/ethereum-optimism/op-geth/blob/c50337a60a1309a0f1dca3bf33ed1bb38c46cdd7/eth/catalyst/api.go#L206-L218
257 258 259 260 261 262 263
func (ea *L2EngineAPI) verifyPayloadAttributes(attr *eth.PayloadAttributes) error {
	c := ea.config()

	// Verify withdrawals attribute for Shanghai.
	if err := checkAttribute(c.IsShanghai, attr.Withdrawals != nil, c.LondonBlock, uint64(attr.Timestamp)); err != nil {
		return fmt.Errorf("invalid withdrawals: %w", err)
	}
264 265 266 267 268
	// Verify beacon root attribute for Cancun.
	if err := checkAttribute(c.IsCancun, attr.ParentBeaconBlockRoot != nil, c.LondonBlock, uint64(attr.Timestamp)); err != nil {
		return fmt.Errorf("invalid parent beacon block root: %w", err)
	}

269 270 271 272 273 274 275 276 277 278 279 280 281
	return nil
}

func checkAttribute(active func(*big.Int, uint64) bool, exists bool, block *big.Int, time uint64) error {
	if active(block, time) && !exists {
		return errors.New("fork active, missing expected attribute")
	}
	if !active(block, time) && exists {
		return errors.New("fork inactive, unexpected attribute set")
	}
	return nil
}

282
func (ea *L2EngineAPI) NewPayloadV1(ctx context.Context, payload *eth.ExecutionPayload) (*eth.PayloadStatusV1, error) {
283 284 285 286
	if payload.Withdrawals != nil {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("withdrawals not supported in V1"))
	}

287
	return ea.newPayload(ctx, payload, nil, nil)
288 289
}

Danyal Prout's avatar
Danyal Prout committed
290
func (ea *L2EngineAPI) NewPayloadV2(ctx context.Context, payload *eth.ExecutionPayload) (*eth.PayloadStatusV1, error) {
291 292 293 294 295 296 297 298
	if ea.config().IsShanghai(new(big.Int).SetUint64(uint64(payload.BlockNumber)), uint64(payload.Timestamp)) {
		if payload.Withdrawals == nil {
			return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("nil withdrawals post-shanghai"))
		}
	} else if payload.Withdrawals != nil {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("non-nil withdrawals pre-shanghai"))
	}

299
	return ea.newPayload(ctx, payload, nil, nil)
Danyal Prout's avatar
Danyal Prout committed
300 301
}

302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
// Ported from: https://github.com/ethereum-optimism/op-geth/blob/c50337a60a1309a0f1dca3bf33ed1bb38c46cdd7/eth/catalyst/api.go#L486C1-L507
func (ea *L2EngineAPI) NewPayloadV3(ctx context.Context, params *eth.ExecutionPayload, versionedHashes []common.Hash, beaconRoot *common.Hash) (*eth.PayloadStatusV1, error) {
	if params.ExcessBlobGas == nil {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("nil excessBlobGas post-cancun"))
	}
	if params.BlobGasUsed == nil {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("nil params.BlobGasUsed post-cancun"))
	}
	if versionedHashes == nil {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("nil versionedHashes post-cancun"))
	}
	if beaconRoot == nil {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.InvalidParams.With(errors.New("nil parentBeaconBlockRoot post-cancun"))
	}

	if !ea.config().IsCancun(new(big.Int).SetUint64(uint64(params.BlockNumber)), uint64(params.Timestamp)) {
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, engine.UnsupportedFork.With(errors.New("newPayloadV3 called pre-cancun"))
	}

	return ea.newPayload(ctx, params, versionedHashes, beaconRoot)
}

324
func (ea *L2EngineAPI) getPayload(_ context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayloadEnvelope, error) {
325 326 327
	ea.log.Trace("L2Engine API request received", "method", "GetPayload", "id", payloadId)
	if ea.payloadID != payloadId {
		ea.log.Warn("unexpected payload ID requested for block building", "expected", ea.payloadID, "got", payloadId)
328
		return nil, engine.UnknownPayload
329 330 331 332
	}
	bl, err := ea.endBlock()
	if err != nil {
		ea.log.Error("failed to finish block building", "err", err)
333
		return nil, engine.UnknownPayload
334
	}
335

336
	return eth.BlockAsPayloadEnv(bl, ea.config().ShanghaiTime)
337 338
}

339
func (ea *L2EngineAPI) forkchoiceUpdated(_ context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error) {
340 341 342 343 344 345 346 347
	ea.log.Trace("L2Engine API request received", "method", "ForkchoiceUpdated", "head", state.HeadBlockHash, "finalized", state.FinalizedBlockHash, "safe", state.SafeBlockHash)
	if state.HeadBlockHash == (common.Hash{}) {
		ea.log.Warn("Forkchoice requested update to zero hash")
		return STATUS_INVALID, nil
	}
	// Check whether we have the block yet in our database or not. If not, we'll
	// need to either trigger a sync, or to reject this forkchoice update for a
	// reason.
348
	block := ea.backend.GetBlockByHash(state.HeadBlockHash)
349
	if block == nil {
350 351 352 353 354 355 356 357 358 359 360 361 362 363
		if ea.downloader == nil {
			ea.log.Warn("Must register downloader to be able to snap sync")
			return STATUS_SYNCING, nil
		}
		// If the head hash is unknown (was not given to us in a newPayload request),
		// we cannot resolve the header, so not much to do. This could be extended in
		// the future to resolve from the `eth` network, but it's an unexpected case
		// that should be fixed, not papered over.
		header := ea.remotes[state.HeadBlockHash]
		if header == nil {
			ea.log.Warn("Forkchoice requested unknown head", "hash", state.HeadBlockHash)
			return STATUS_SYNCING, nil
		}

364
		ea.log.Info("Forkchoice requested sync to new head", "number", header.Number(), "hash", header.Hash())
365 366 367
		if err := ea.downloader.BeaconSync(downloader.SnapSync, header.Header(), nil); err != nil {
			return STATUS_SYNCING, err
		}
368 369 370 371
		return STATUS_SYNCING, nil
	}
	// Block is known locally, just sanity check that the beacon client does not
	// attempt to push us back to before the merge.
372
	// Note: Differs from op-geth implementation as pre-merge blocks are never supported here
373
	if block.Difficulty().BitLen() > 0 && block.NumberU64() > 0 {
374
		return STATUS_INVALID, errors.New("pre-merge blocks not supported")
375
	}
376
	valid := func(id *engine.PayloadID) *eth.ForkchoiceUpdatedResult {
377 378 379 380 381
		return &eth.ForkchoiceUpdatedResult{
			PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionValid, LatestValidHash: &state.HeadBlockHash},
			PayloadID:     id,
		}
	}
382
	if ea.backend.GetCanonicalHash(block.NumberU64()) != state.HeadBlockHash {
383
		// Block is not canonical, set head.
384
		if latestValid, err := ea.backend.SetCanonical(block); err != nil {
385 386
			return &eth.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionInvalid, LatestValidHash: &latestValid}}, err
		}
387
	} else if ea.backend.CurrentHeader().Hash() == state.HeadBlockHash {
388 389 390
		// If the specified head matches with our local head, do nothing and keep
		// generating the payload. It's a special corner case that a few slots are
		// missing and we are requested to generate the payload in slot.
391
	} else if ea.backend.Config().Optimism == nil { // minor L2Engine API divergence: allow proposers to reorg their own chain
392 393 394 395 396 397 398
		panic("engine not configured as optimism engine")
	}

	// If the beacon client also advertised a finalized block, mark the local
	// chain final and completely in PoS mode.
	if state.FinalizedBlockHash != (common.Hash{}) {
		// If the finalized block is not in our canonical tree, somethings wrong
399
		finalHeader := ea.backend.GetHeaderByHash(state.FinalizedBlockHash)
400
		if finalHeader == nil {
401
			ea.log.Warn("Final block not available in database", "hash", state.FinalizedBlockHash)
402
			return STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("final block not available in database"))
403
		} else if ea.backend.GetCanonicalHash(finalHeader.Number.Uint64()) != state.FinalizedBlockHash {
404
			ea.log.Warn("Final block not in canonical chain", "number", block.NumberU64(), "hash", state.HeadBlockHash)
405
			return STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("final block not in canonical chain"))
406 407
		}
		// Set the finalized block
408
		ea.backend.SetFinalized(finalHeader)
409 410 411
	}
	// Check if the safe block hash is in our canonical tree, if not somethings wrong
	if state.SafeBlockHash != (common.Hash{}) {
412
		safeHeader := ea.backend.GetHeaderByHash(state.SafeBlockHash)
413
		if safeHeader == nil {
414
			ea.log.Warn("Safe block not available in database")
415
			return STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("safe block not available in database"))
416
		}
417
		if ea.backend.GetCanonicalHash(safeHeader.Number.Uint64()) != state.SafeBlockHash {
418
			ea.log.Warn("Safe block not in canonical chain")
419
			return STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("safe block not in canonical chain"))
420 421
		}
		// Set the safe block
422
		ea.backend.SetSafe(safeHeader)
423 424 425 426 427 428 429 430
	}
	// If payload generation was requested, create a new block to be potentially
	// sealed by the beacon client. The payload will be requested later, and we
	// might replace it arbitrarily many times in between.
	if attr != nil {
		err := ea.startBlock(state.HeadBlockHash, attr)
		if err != nil {
			ea.log.Error("Failed to start block building", "err", err, "noTxPool", attr.NoTxPool, "txs", len(attr.Transactions), "timestamp", attr.Timestamp)
431
			return STATUS_INVALID, engine.InvalidPayloadAttributes.With(err)
432 433 434 435 436 437 438
		}

		return valid(&ea.payloadID), nil
	}
	return valid(nil), nil
}

Danyal Prout's avatar
Danyal Prout committed
439 440 441 442 443
func toGethWithdrawals(payload *eth.ExecutionPayload) []*types.Withdrawal {
	if payload.Withdrawals == nil {
		return nil
	}

Danyal Prout's avatar
Danyal Prout committed
444
	result := make([]*types.Withdrawal, 0, len(*payload.Withdrawals))
Danyal Prout's avatar
Danyal Prout committed
445 446 447 448 449 450 451 452 453 454 455 456 457

	for _, w := range *payload.Withdrawals {
		result = append(result, &types.Withdrawal{
			Index:     w.Index,
			Validator: w.Validator,
			Address:   w.Address,
			Amount:    w.Amount,
		})
	}

	return result
}

458
func (ea *L2EngineAPI) newPayload(_ context.Context, payload *eth.ExecutionPayload, hashes []common.Hash, root *common.Hash) (*eth.PayloadStatusV1, error) {
459 460 461 462 463
	ea.log.Trace("L2Engine API request received", "method", "ExecutePayload", "number", payload.BlockNumber, "hash", payload.BlockHash)
	txs := make([][]byte, len(payload.Transactions))
	for i, tx := range payload.Transactions {
		txs[i] = tx
	}
464
	block, err := engine.ExecutableDataToBlock(engine.ExecutableData{
465 466 467 468 469 470 471 472 473 474 475
		ParentHash:    payload.ParentHash,
		FeeRecipient:  payload.FeeRecipient,
		StateRoot:     common.Hash(payload.StateRoot),
		ReceiptsRoot:  common.Hash(payload.ReceiptsRoot),
		LogsBloom:     payload.LogsBloom[:],
		Random:        common.Hash(payload.PrevRandao),
		Number:        uint64(payload.BlockNumber),
		GasLimit:      uint64(payload.GasLimit),
		GasUsed:       uint64(payload.GasUsed),
		Timestamp:     uint64(payload.Timestamp),
		ExtraData:     payload.ExtraData,
476
		BaseFeePerGas: (*uint256.Int)(&payload.BaseFeePerGas).ToBig(),
477 478
		BlockHash:     payload.BlockHash,
		Transactions:  txs,
Danyal Prout's avatar
Danyal Prout committed
479
		Withdrawals:   toGethWithdrawals(payload),
480 481 482
		ExcessBlobGas: (*uint64)(payload.ExcessBlobGas),
		BlobGasUsed:   (*uint64)(payload.BlobGasUsed),
	}, hashes, root)
483 484 485 486 487 488
	if err != nil {
		log.Debug("Invalid NewPayload params", "params", payload, "error", err)
		return &eth.PayloadStatusV1{Status: eth.ExecutionInvalidBlockHash}, nil
	}
	// If we already have the block locally, ignore the entire execution and just
	// return a fake success.
489
	if block := ea.backend.GetBlock(payload.BlockHash, uint64(payload.BlockNumber)); block != nil {
490
		ea.log.Info("Using existing beacon payload", "number", payload.BlockNumber, "hash", payload.BlockHash, "age", common.PrettyAge(time.Unix(int64(block.Time()), 0)))
491 492 493 494
		hash := block.Hash()
		return &eth.PayloadStatusV1{Status: eth.ExecutionValid, LatestValidHash: &hash}, nil
	}

495
	// Skip invalid ancestor check (i.e. not remembering previously failed blocks)
496

497
	parent := ea.backend.GetBlock(block.ParentHash(), block.NumberU64()-1)
498
	if parent == nil {
499
		ea.remotes[block.Hash()] = block
500
		// Return accepted if we don't know the parent block. Note that there's no actual sync to activate.
501 502
		return &eth.PayloadStatusV1{Status: eth.ExecutionAccepted, LatestValidHash: nil}, nil
	}
503 504 505 506 507 508 509

	if block.Time() <= parent.Time() {
		log.Warn("Invalid timestamp", "parent", block.Time(), "block", block.Time())
		return ea.invalid(errors.New("invalid timestamp"), parent.Header()), nil
	}

	if !ea.backend.HasBlockAndState(block.ParentHash(), block.NumberU64()-1) {
510 511 512
		ea.log.Warn("State not available, ignoring new payload")
		return &eth.PayloadStatusV1{Status: eth.ExecutionAccepted}, nil
	}
513
	log.Trace("Inserting block without sethead", "hash", block.Hash(), "number", block.Number)
514
	if _, err := ea.backend.InsertBlockWithoutSetHead(block, false); err != nil {
515
		ea.log.Warn("NewPayloadV1: inserting block failed", "error", err)
516
		// Skip remembering the block was invalid, but do return the invalid response.
517 518 519 520 521 522 523
		return ea.invalid(err, parent.Header()), nil
	}
	hash := block.Hash()
	return &eth.PayloadStatusV1{Status: eth.ExecutionValid, LatestValidHash: &hash}, nil
}

func (ea *L2EngineAPI) invalid(err error, latestValid *types.Header) *eth.PayloadStatusV1 {
524
	currentHash := ea.backend.CurrentHeader().Hash()
525 526 527 528 529 530 531 532 533 534 535
	if latestValid != nil {
		// Set latest valid hash to 0x0 if parent is PoW block
		currentHash = common.Hash{}
		if latestValid.Difficulty.BitLen() == 0 {
			// Otherwise set latest valid hash to parent hash
			currentHash = latestValid.Hash()
		}
	}
	errorMsg := err.Error()
	return &eth.PayloadStatusV1{Status: eth.ExecutionInvalid, LatestValidHash: &currentHash, ValidationError: &errorMsg}
}