op-node: unify verifier and sequencer payload attributes preparation (#2925)

* op-node: unify verifier and sequencer payload attributes preparation

* op-node: test attributes derivation

* op-node: test AttributesQueue

* op-node: update attributes derivation docs
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

op-node/rollup/derive/attributes.go

+package derive
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// L1ReceiptsFetcher fetches L1 header info and receipts for the payload attributes derivation (the info tx and deposits)
+type L1ReceiptsFetcher interface {
+	InfoByHash(ctx context.Context, hash common.Hash) (eth.L1Info, error)
+	Fetch(ctx context.Context, blockHash common.Hash) (eth.L1Info, types.Transactions, types.Receipts, error)
+}
+
+// PreparePayloadAttributes prepares a PayloadAttributes template that is ready to build a L2 block with deposits only, on top of the given l2Parent, with the given epoch as L1 origin.
+// The template defaults to NoTxPool=true, and no sequencer transactions: the caller has to modify the template to add transactions,
+// by setting NoTxPool=false as sequencer, or by appending batch transactions as verifier.
+// The severity of the error is returned; a crit=false error means there was a temporary issue, like a failed RPC or time-out.
+// A crit=true error means the input arguments are inconsistent or invalid.
+func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1ReceiptsFetcher, l2Parent eth.L2BlockRef, epoch eth.BlockID) (attrs *eth.PayloadAttributes, crit bool, err error) {
+	var l1Info eth.L1Info
+	var depositTxs []hexutil.Bytes
+	var seqNumber uint64
+
+	// If the L1 origin changed this block, then we are in the first block of the epoch. In this
+	// case we need to fetch all transaction receipts from the L1 origin block so we can scan for
+	// user deposits.
+	if l2Parent.L1Origin.Number != epoch.Number {
+		info, _, receipts, err := dl.Fetch(ctx, epoch.Hash)
+		if err != nil {
+			return nil, false, fmt.Errorf("failed to fetch L1 block info and receipts: %w", err)
+		}
+		if l2Parent.L1Origin.Hash != info.ParentHash() {
+			return nil, true, fmt.Errorf("cannot create new block with L1 origin %s (parent %s) on top of L1 origin %s", epoch, info.ParentHash(), l2Parent.L1Origin)
+		}
+		deposits, err := DeriveDeposits(receipts, cfg.DepositContractAddress)
+		if err != nil {
+			return nil, true, fmt.Errorf("failed to derive some deposits: %w", err)
+		}
+		l1Info = info
+		depositTxs = deposits
+		seqNumber = 0
+	} else {
+		if l2Parent.L1Origin.Hash != epoch.Hash {
+			return nil, true, fmt.Errorf("cannot create new block with L1 origin %s in conflict with L1 origin %s", epoch, l2Parent.L1Origin)
+		}
+		info, err := dl.InfoByHash(ctx, epoch.Hash)
+		if err != nil {
+			return nil, false, fmt.Errorf("failed to fetch L1 block info: %w", err)
+		}
+		l1Info = info
+		depositTxs = nil
+		seqNumber = l2Parent.SequenceNumber + 1
+	}
+
+	l1InfoTx, err := L1InfoDepositBytes(seqNumber, l1Info)
+	if err != nil {
+		return nil, true, fmt.Errorf("failed to create l1InfoTx: %w", err)
+	}
+
+	txs := make([]hexutil.Bytes, 0, 1+len(depositTxs))
+	txs = append(txs, l1InfoTx)
+	txs = append(txs, depositTxs...)
+
+	return &eth.PayloadAttributes{
+		Timestamp:             hexutil.Uint64(l2Parent.Time + cfg.BlockTime),
+		PrevRandao:            eth.Bytes32(l1Info.MixDigest()),
+		SuggestedFeeRecipient: cfg.FeeRecipientAddress,
+		Transactions:          txs,
+		NoTxPool:              true,
+	}, false, nil
+}

op-node/rollup/derive/attributes_queue.go

@@ -8,16 +8,9 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
-	"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/log"
 )
 
-type L1ReceiptsFetcher interface {
-	Fetch(ctx context.Context, blockHash common.Hash) (eth.L1Info, types.Transactions, types.Receipts, error)
-}
-
 type AttributesQueueOutput interface {
 	AddSafeAttributes(attributes *eth.PayloadAttributes)
 	SafeL2Head() eth.L2BlockRef
@@ -55,82 +48,43 @@ func (aq *AttributesQueue) Step(ctx context.Context, outer Progress) error {
 	if changed, err := aq.progress.Update(outer); err != nil || changed {
 		return err
 	}
-	attr, err := aq.DeriveL2Inputs(ctx, aq.next.SafeL2Head())
-	if err != nil {
-		return err
-	}
-	aq.next.AddSafeAttributes(attr)
-	return nil
-}
-
-func (aq *AttributesQueue) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error {
-	aq.batches = aq.batches[:0]
-	aq.progress = aq.next.Progress()
-	return io.EOF
-}
-
-func (aq *AttributesQueue) SafeL2Head() eth.L2BlockRef {
-	return aq.next.SafeL2Head()
-}
-
-// DeriveL2Inputs turns the next L2 batch into an Payload Attributes that builds off of the safe head
-func (aq *AttributesQueue) DeriveL2Inputs(ctx context.Context, l2SafeHead eth.L2BlockRef) (*eth.PayloadAttributes, error) {
 	if len(aq.batches) == 0 {
-		return nil, io.EOF
+		return io.EOF
 	}
 	batch := aq.batches[0]
 
-	seqNumber := l2SafeHead.SequenceNumber + 1
-	// Check if we need to advance an epoch & update local state
-	if l2SafeHead.L1Origin != batch.Epoch() {
-		aq.log.Info("advancing epoch in the attributes queue", "l2SafeHead", l2SafeHead, "l2SafeHead_origin", l2SafeHead.L1Origin, "batch_timestamp", batch.Timestamp, "batch_epoch", batch.Epoch())
-		seqNumber = 0
-	}
-
 	fetchCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
 	defer cancel()
-	l1Info, _, receipts, err := aq.dl.Fetch(fetchCtx, batch.EpochHash)
+	attrs, crit, err := PreparePayloadAttributes(fetchCtx, aq.config, aq.dl, aq.next.SafeL2Head(), batch.Epoch())
 	if err != nil {
-		aq.log.Error("failed to fetch L1 block info", "l1Origin", batch.Epoch(), "err", err)
-		return nil, err
-	}
-
-	// Fill in deposits if we are the first block of the epoch
-	var deposits []hexutil.Bytes
-	if seqNumber == 0 {
-		var errs []error
-		deposits, errs = DeriveDeposits(receipts, aq.config.DepositContractAddress)
-		for _, err := range errs {
-			aq.log.Error("Failed to derive a deposit", "l1Origin", batch.Epoch(), "err", err)
-		}
-		if len(errs) != 0 {
-			// TODO: Multierror here
-			return nil, fmt.Errorf("failed to derive some deposits: %v", errs)
+		if crit {
+			return fmt.Errorf("failed to prepare payload attributes for batch: %v", err)
+		} else {
+			aq.log.Error("temporarily failing to prepare payload attributes for batch", "err", err)
+			return nil
 		}
 	}
 
-	var txns []eth.Data
-	l1InfoTx, err := L1InfoDepositBytes(seqNumber, l1Info)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create l1InfoTx: %w", err)
-	}
-	txns = append(txns, l1InfoTx)
-	if seqNumber == 0 {
-		txns = append(txns, deposits...)
-	}
-	txns = append(txns, batch.Transactions...)
-	attrs := &eth.PayloadAttributes{
-		Timestamp:             hexutil.Uint64(batch.Timestamp),
-		PrevRandao:            eth.Bytes32(l1Info.MixDigest()),
-		SuggestedFeeRecipient: aq.config.FeeRecipientAddress,
-		Transactions:          txns,
-		// we are verifying, not sequencing, we've got all transactions and do not pull from the tx-pool
-		// (that would make the block derivation non-deterministic)
-		NoTxPool: true,
-	}
-	aq.log.Info("generated attributes in payload queue", "tx_count", len(txns), "timestamp", batch.Timestamp)
+	// we are verifying, not sequencing, we've got all transactions and do not pull from the tx-pool
+	// (that would make the block derivation non-deterministic)
+	attrs.NoTxPool = true
+	attrs.Transactions = append(attrs.Transactions, batch.Transactions...)
+
+	aq.log.Info("generated attributes in payload queue", "txs", len(attrs.Transactions), "timestamp", batch.Timestamp)
 
 	// Slice off the batch once we are guaranteed to succeed
 	aq.batches = aq.batches[1:]
-	return attrs, nil
+
+	aq.next.AddSafeAttributes(attrs)
+	return nil
+}
+
+func (aq *AttributesQueue) ResetStep(ctx context.Context, l1Fetcher L1Fetcher) error {
+	aq.batches = aq.batches[:0]
+	aq.progress = aq.next.Progress()
+	return io.EOF
+}
+
+func (aq *AttributesQueue) SafeL2Head() eth.L2BlockRef {
+	return aq.next.SafeL2Head()
 }

op-node/rollup/derive/attributes_queue_test.go

 package derive
+
+import (
+	"context"
+	"io"
+	"math/big"
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/stretchr/testify/require"
+)
+
+type MockAttributesQueueOutput struct {
+	MockOriginStage
+}
+
+func (m *MockAttributesQueueOutput) AddSafeAttributes(attributes *eth.PayloadAttributes) {
+	m.Mock.MethodCalled("AddSafeAttributes", attributes)
+}
+
+func (m *MockAttributesQueueOutput) ExpectAddSafeAttributes(attributes *eth.PayloadAttributes) {
+	m.Mock.On("AddSafeAttributes", attributes).Once().Return()
+}
+
+func (m *MockAttributesQueueOutput) SafeL2Head() eth.L2BlockRef {
+	return m.Mock.MethodCalled("SafeL2Head").Get(0).(eth.L2BlockRef)
+}
+
+func (m *MockAttributesQueueOutput) ExpectSafeL2Head(head eth.L2BlockRef) {
+	m.Mock.On("SafeL2Head").Once().Return(head)
+}
+
+var _ AttributesQueueOutput = (*MockAttributesQueueOutput)(nil)
+
+func TestAttributesQueue_Step(t *testing.T) {
+	// test config, only init the necessary fields
+	cfg := &rollup.Config{
+		BlockTime:              2,
+		L1ChainID:              big.NewInt(101),
+		L2ChainID:              big.NewInt(102),
+		FeeRecipientAddress:    common.Address{0xaa},
+		DepositContractAddress: common.Address{0xbb},
+	}
+	rng := rand.New(rand.NewSource(1234))
+	l1Info := testutils.RandomL1Info(rng)
+
+	l1Fetcher := &testutils.MockL1Source{}
+	defer l1Fetcher.AssertExpectations(t)
+
+	l1Fetcher.ExpectInfoByHash(l1Info.InfoHash, l1Info, nil)
+
+	out := &MockAttributesQueueOutput{}
+	out.progress = Progress{
+		Origin: l1Info.BlockRef(),
+		Closed: false,
+	}
+	defer out.AssertExpectations(t)
+
+	safeHead := testutils.RandomL2BlockRef(rng)
+	safeHead.L1Origin = l1Info.ID()
+
+	out.ExpectSafeL2Head(safeHead)
+
+	batch := &BatchData{BatchV1{
+		EpochNum:     rollup.Epoch(l1Info.InfoNum),
+		EpochHash:    l1Info.InfoHash,
+		Timestamp:    12345,
+		Transactions: []eth.Data{eth.Data("foobar"), eth.Data("example")},
+	}}
+
+	l1InfoTx, err := L1InfoDepositBytes(safeHead.SequenceNumber+1, l1Info)
+	require.NoError(t, err)
+	attrs := eth.PayloadAttributes{
+		Timestamp:             eth.Uint64Quantity(safeHead.Time + cfg.BlockTime),
+		PrevRandao:            eth.Bytes32(l1Info.InfoMixDigest),
+		SuggestedFeeRecipient: cfg.FeeRecipientAddress,
+		Transactions:          []eth.Data{l1InfoTx, eth.Data("foobar"), eth.Data("example")},
+		NoTxPool:              true,
+	}
+	out.ExpectAddSafeAttributes(&attrs)
+
+	aq := NewAttributesQueue(testlog.Logger(t, log.LvlError), cfg, l1Fetcher, out)
+	require.NoError(t, RepeatResetStep(t, aq.ResetStep, l1Fetcher, 1))
+
+	aq.AddBatch(batch)
+
+	require.NoError(t, aq.Step(context.Background(), out.progress), "adding batch to next stage, no EOF yet")
+	require.Equal(t, io.EOF, aq.Step(context.Background(), out.progress), "done with batches")
+}

op-node/rollup/derive/attributes_test.go

+package derive
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPreparePayloadAttributes(t *testing.T) {
+	// test config, only init the necessary fields
+	cfg := &rollup.Config{
+		BlockTime:              2,
+		L1ChainID:              big.NewInt(101),
+		L2ChainID:              big.NewInt(102),
+		FeeRecipientAddress:    common.Address{0xaa},
+		DepositContractAddress: common.Address{0xbb},
+	}
+
+	t.Run("inconsistent next height origin", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		l1Info := testutils.RandomL1Info(rng)
+		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
+		epoch := l1Info.ID()
+		l1Fetcher.ExpectFetch(epoch.Hash, l1Info, nil, nil, nil)
+		_, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.NotNil(t, err, "inconsistent L1 origin error expected")
+		require.True(t, crit, "inconsistent L1 origin transition must be handled like a critical error with reorg")
+	})
+	t.Run("inconsistent equal height origin", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		l1Info := testutils.RandomL1Info(rng)
+		l1Info.InfoNum = l2Parent.L1Origin.Number
+		epoch := l1Info.ID()
+		_, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.NotNil(t, err, "inconsistent L1 origin error expected")
+		require.True(t, crit, "inconsistent L1 origin transition must be handled like a critical error with reorg")
+	})
+	t.Run("rpc fail Fetch", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		epoch := l2Parent.L1Origin
+		epoch.Number += 1
+		mockRPCErr := errors.New("mock rpc error")
+		l1Fetcher.ExpectFetch(epoch.Hash, nil, nil, nil, mockRPCErr)
+		_, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.ErrorIs(t, err, mockRPCErr, "mock rpc error expected")
+		require.False(t, crit, "rpc errors should not be critical, it is not necessary to reorg")
+	})
+	t.Run("rpc fail InfoByHash", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		epoch := l2Parent.L1Origin
+		mockRPCErr := errors.New("mock rpc error")
+		l1Fetcher.ExpectInfoByHash(epoch.Hash, nil, mockRPCErr)
+		_, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.ErrorIs(t, err, mockRPCErr, "mock rpc error expected")
+		require.False(t, crit, "rpc errors should not be critical, it is not necessary to reorg")
+	})
+	t.Run("next origin without deposits", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		l1Info := testutils.RandomL1Info(rng)
+		l1Info.InfoParentHash = l2Parent.L1Origin.Hash
+		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
+		epoch := l1Info.ID()
+		l1InfoTx, err := L1InfoDepositBytes(0, l1Info)
+		require.NoError(t, err)
+		l1Fetcher.ExpectFetch(epoch.Hash, l1Info, nil, nil, nil)
+		attrs, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.NoError(t, err)
+		require.False(t, crit)
+		require.NotNil(t, attrs)
+		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))
+		require.Equal(t, eth.Bytes32(l1Info.InfoMixDigest), attrs.PrevRandao)
+		require.Equal(t, cfg.FeeRecipientAddress, attrs.SuggestedFeeRecipient)
+		require.Equal(t, 1, len(attrs.Transactions))
+		require.Equal(t, l1InfoTx, []byte(attrs.Transactions[0]))
+		require.True(t, attrs.NoTxPool)
+	})
+	t.Run("next origin with deposits", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		l1Info := testutils.RandomL1Info(rng)
+		l1Info.InfoParentHash = l2Parent.L1Origin.Hash
+		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
+
+		receipts, depositTxs := makeReceipts(rng, l1Info.InfoHash, cfg.DepositContractAddress, []receiptData{
+			{goodReceipt: true, DepositLogs: []bool{true, false}},
+			{goodReceipt: true, DepositLogs: []bool{true}},
+			{goodReceipt: false, DepositLogs: []bool{true}},
+			{goodReceipt: false, DepositLogs: []bool{false}},
+		})
+		usedDepositTxs, err := encodeDeposits(depositTxs)
+		require.NoError(t, err)
+
+		epoch := l1Info.ID()
+		l1InfoTx, err := L1InfoDepositBytes(0, l1Info)
+		require.NoError(t, err)
+
+		l2Txs := append(append(make([]eth.Data, 0), l1InfoTx), usedDepositTxs...)
+
+		// txs are ignored, API is a bit bloated to previous approach. Only l1Info and receipts matter.
+		l1Txs := make(types.Transactions, len(receipts))
+		l1Fetcher.ExpectFetch(epoch.Hash, l1Info, l1Txs, receipts, nil)
+		attrs, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.NoError(t, err)
+		require.False(t, crit)
+		require.NotNil(t, attrs)
+		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))
+		require.Equal(t, eth.Bytes32(l1Info.InfoMixDigest), attrs.PrevRandao)
+		require.Equal(t, cfg.FeeRecipientAddress, attrs.SuggestedFeeRecipient)
+		require.Equal(t, len(l2Txs), len(attrs.Transactions), "Expected txs to equal l1 info tx + user deposit txs")
+		require.Equal(t, l2Txs, attrs.Transactions)
+		require.True(t, attrs.NoTxPool)
+	})
+	t.Run("same origin again", func(t *testing.T) {
+		rng := rand.New(rand.NewSource(1234))
+		l1Fetcher := &testutils.MockL1Source{}
+		defer l1Fetcher.AssertExpectations(t)
+		l2Parent := testutils.RandomL2BlockRef(rng)
+		l1Info := testutils.RandomL1Info(rng)
+		l1Info.InfoHash = l2Parent.L1Origin.Hash
+		l1Info.InfoNum = l2Parent.L1Origin.Number
+
+		epoch := l1Info.ID()
+		l1InfoTx, err := L1InfoDepositBytes(l2Parent.SequenceNumber+1, l1Info)
+		require.NoError(t, err)
+
+		l1Fetcher.ExpectInfoByHash(epoch.Hash, l1Info, nil)
+		attrs, crit, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l2Parent, epoch)
+		require.NoError(t, err)
+		require.False(t, crit)
+		require.NotNil(t, attrs)
+		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))
+		require.Equal(t, eth.Bytes32(l1Info.InfoMixDigest), attrs.PrevRandao)
+		require.Equal(t, cfg.FeeRecipientAddress, attrs.SuggestedFeeRecipient)
+		require.Equal(t, 1, len(attrs.Transactions))
+		require.Equal(t, l1InfoTx, []byte(attrs.Transactions[0]))
+		require.True(t, attrs.NoTxPool)
+	})
+}
+
+func encodeDeposits(deposits []*types.DepositTx) (out []eth.Data, err error) {
+	for i, tx := range deposits {
+		opaqueTx, err := types.NewTx(tx).MarshalBinary()
+		if err != nil {
+			return nil, fmt.Errorf("bad deposit %d: %v", i, err)
+		}
+		out = append(out, opaqueTx)
+	}
+	return
+}

op-node/rollup/derive/deposit_log_test.go

@@ -6,8 +6,10 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestUnmarshalLogEvent(t *testing.T) {
@@ -43,6 +45,44 @@ type receiptData struct {
 	DepositLogs []bool
 }
 
+func makeReceipts(rng *rand.Rand, blockHash common.Hash, depositContractAddr common.Address, testReceipts []receiptData) (receipts []*types.Receipt, expectedDeposits []*types.DepositTx) {
+	logIndex := uint(0)
+	for txIndex, rData := range testReceipts {
+		var logs []*types.Log
+		status := types.ReceiptStatusSuccessful
+		if !rData.goodReceipt {
+			status = types.ReceiptStatusFailed
+		}
+		for _, isDeposit := range rData.DepositLogs {
+			var ev *types.Log
+			if isDeposit {
+				source := UserDepositSource{L1BlockHash: blockHash, LogIndex: uint64(logIndex)}
+				dep := testutils.GenerateDeposit(source.SourceHash(), rng)
+				if status == types.ReceiptStatusSuccessful {
+					expectedDeposits = append(expectedDeposits, dep)
+				}
+				ev = MarshalDepositLogEvent(depositContractAddr, dep)
+			} else {
+				ev = testutils.GenerateLog(testutils.RandomAddress(rng), nil, nil)
+			}
+			ev.TxIndex = uint(txIndex)
+			ev.Index = logIndex
+			ev.BlockHash = blockHash
+			logs = append(logs, ev)
+			logIndex++
+		}
+
+		receipts = append(receipts, &types.Receipt{
+			Type:             types.DynamicFeeTxType,
+			Status:           status,
+			Logs:             logs,
+			BlockHash:        blockHash,
+			TransactionIndex: uint(txIndex),
+		})
+	}
+	return
+}
+
 type DeriveUserDepositsTestCase struct {
 	name string
 	// generate len(receipts) receipts
@@ -64,49 +104,14 @@ func TestDeriveUserDeposits(t *testing.T) {
 	for i, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
 			rng := rand.New(rand.NewSource(1234 + int64(i)))
-			var receipts []*types.Receipt
-			var expectedDeposits []*types.DepositTx
-			logIndex := uint(0)
 			blockHash := testutils.RandomHash(rng)
-			for txIndex, rData := range testCase.receipts {
-				var logs []*types.Log
-				status := types.ReceiptStatusSuccessful
-				if !rData.goodReceipt {
-					status = types.ReceiptStatusFailed
-				}
-				for _, isDeposit := range rData.DepositLogs {
-					var ev *types.Log
-					if isDeposit {
-						source := UserDepositSource{L1BlockHash: blockHash, LogIndex: uint64(logIndex)}
-						dep := testutils.GenerateDeposit(source.SourceHash(), rng)
-						if status == types.ReceiptStatusSuccessful {
-							expectedDeposits = append(expectedDeposits, dep)
-						}
-						ev = MarshalDepositLogEvent(MockDepositContractAddr, dep)
-					} else {
-						ev = testutils.GenerateLog(testutils.RandomAddress(rng), nil, nil)
-					}
-					ev.TxIndex = uint(txIndex)
-					ev.Index = logIndex
-					ev.BlockHash = blockHash
-					logs = append(logs, ev)
-					logIndex++
-				}
-
-				receipts = append(receipts, &types.Receipt{
-					Type:             types.DynamicFeeTxType,
-					Status:           status,
-					Logs:             logs,
-					BlockHash:        blockHash,
-					TransactionIndex: uint(txIndex),
-				})
-			}
-			got, errs := UserDeposits(receipts, MockDepositContractAddr)
-			assert.Equal(t, len(errs), 0)
-			assert.Equal(t, len(got), len(expectedDeposits))
+			receipts, expectedDeposits := makeReceipts(rng, blockHash, MockDepositContractAddr, testCase.receipts)
+			got, err := UserDeposits(receipts, MockDepositContractAddr)
+			require.NoError(t, err)
+			require.Equal(t, len(got), len(expectedDeposits))
 			for d, depTx := range got {
 				expected := expectedDeposits[d]
-				assert.Equal(t, expected, depTx)
+				require.Equal(t, expected, depTx)
 			}
 		})
 	}

op-node/rollup/derive/deposits.go

@@ -3,16 +3,17 @@ package derive
 import (
 	"fmt"
 
+	"github.com/hashicorp/go-multierror"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
 // UserDeposits transforms the L2 block-height and L1 receipts into the transaction inputs for a full L2 block
-func UserDeposits(receipts []*types.Receipt, depositContractAddr common.Address) ([]*types.DepositTx, []error) {
+func UserDeposits(receipts []*types.Receipt, depositContractAddr common.Address) ([]*types.DepositTx, error) {
 	var out []*types.DepositTx
-	var errs []error
-
+	var result error
 	for i, rec := range receipts {
 		if rec.Status != types.ReceiptStatusSuccessful {
 			continue
@@ -21,26 +22,30 @@ func UserDeposits(receipts []*types.Receipt, depositContractAddr common.Address)
 			if log.Address == depositContractAddr && len(log.Topics) > 0 && log.Topics[0] == DepositEventABIHash {
 				dep, err := UnmarshalDepositLogEvent(log)
 				if err != nil {
-					errs = append(errs, fmt.Errorf("malformatted L1 deposit log in receipt %d, log %d: %w", i, j, err))
+					result = multierror.Append(result, fmt.Errorf("malformatted L1 deposit log in receipt %d, log %d: %w", i, j, err))
 				} else {
 					out = append(out, dep)
 				}
 			}
 		}
 	}
-	return out, errs
+	return out, result
 }
 
-func DeriveDeposits(receipts []*types.Receipt, depositContractAddr common.Address) ([]hexutil.Bytes, []error) {
-	userDeposits, errs := UserDeposits(receipts, depositContractAddr)
+func DeriveDeposits(receipts []*types.Receipt, depositContractAddr common.Address) ([]hexutil.Bytes, error) {
+	var result error
+	userDeposits, err := UserDeposits(receipts, depositContractAddr)
+	if err != nil {
+		result = multierror.Append(result, err)
+	}
 	encodedTxs := make([]hexutil.Bytes, 0, len(userDeposits))
 	for i, tx := range userDeposits {
 		opaqueTx, err := types.NewTx(tx).MarshalBinary()
 		if err != nil {
-			errs = append(errs, fmt.Errorf("failed to encode user tx %d", i))
+			result = multierror.Append(result, fmt.Errorf("failed to encode user tx %d", i))
 		} else {
 			encodedTxs = append(encodedTxs, opaqueTx)
 		}
 	}
-	return encodedTxs, errs
+	return encodedTxs, result
 }

op-node/rollup/driver/step.go

@@ -9,8 +9,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -27,70 +25,16 @@ func (d *outputImpl) createNewBlock(ctx context.Context, l2Head eth.L2BlockRef,
 	fetchCtx, cancel := context.WithTimeout(ctx, time.Second*20)
 	defer cancel()
 
-	var l1Info eth.L1Info
-	var receipts types.Receipts
-	var err error
-
-	seqNumber := l2Head.SequenceNumber + 1
-
-	// If the L1 origin changed this block, then we are in the first block of the epoch. In this
-	// case we need to fetch all transaction receipts from the L1 origin block so we can scan for
-	// user deposits.
-	if l2Head.L1Origin.Number != l1Origin.Number {
-		if l2Head.L1Origin.Hash != l1Origin.ParentHash {
-			d.log.Error("SEQUENCING BUG: cannot create new block on top of l2Head with new origin", "head", l2Head,
-				"head_origin", l2Head.L1Origin, "head_seq_nr", l2Head.SequenceNumber, "new_origin", l1Origin, "new_origin_parent", l1Origin.ParentID())
-			return l2Head, nil, fmt.Errorf("cannot create new block with L1 origin %s (parent %s) on top of L1 origin %s", l1Origin, l1Origin.ParentID(), l2Head.L1Origin)
-		}
-		l1Info, _, receipts, err = d.dl.Fetch(fetchCtx, l1Origin.Hash)
-		seqNumber = 0 // reset sequence number at the start of the epoch
-	} else {
-		if l2Head.L1Origin.Hash != l1Origin.Hash {
-			d.log.Error("SEQUENCING BUG: cannot create new block on top of l2Head with different origin at same height",
-				"head", l2Head, "head_origin", l2Head.L1Origin, "head_seq_nr", l2Head.SequenceNumber, "new_origin", l1Origin, "new_origin_parent", l1Origin.ParentID())
-			return l2Head, nil, fmt.Errorf("cannot create new block with L1 origin %s (parent %s) on top of L1 origin %s", l1Origin, l1Origin.ParentID(), l2Head.L1Origin)
-		}
-		l1Info, err = d.dl.InfoByHash(fetchCtx, l1Origin.Hash)
-	}
-	if err != nil {
-		return l2Head, nil, fmt.Errorf("failed to fetch L1 block info of %s: %v", l1Origin, err)
-	}
-
-	// Start building the list of transactions to include in the new block.
-	var txns []eth.Data
-
-	// First transaction in every block is always the L1 info transaction.
-	l1InfoTx, err := derive.L1InfoDepositBytes(seqNumber, l1Info)
+	attrs, _, err := derive.PreparePayloadAttributes(fetchCtx, d.Config, d.dl, l2Head, l1Origin.ID())
 	if err != nil {
 		return l2Head, nil, err
 	}
-	txns = append(txns, l1InfoTx)
-
-	// Next we append user deposits. If we're not the first block in an epoch, then receipts will
-	// be empty and no deposits will be derived.
-	deposits, errs := derive.DeriveDeposits(receipts, d.Config.DepositContractAddress)
-	d.log.Info("Derived deposits", "deposits", deposits, "l2Parent", l2Head, "l1Origin", l1Origin)
-	for _, err := range errs {
-		d.log.Error("Failed to derive a deposit", "l1OriginHash", l1Origin.Hash, "err", err)
-	}
-	// TODO: Should we halt if len(errs) > 0? Opens up a denial of service attack, but prevents lockup of funds.
-	txns = append(txns, deposits...)
 
 	// If our next L2 block timestamp is beyond the Sequencer drift threshold, then we must produce
 	// empty blocks (other than the L1 info deposit and any user deposits). We handle this by
 	// setting NoTxPool to true, which will cause the Sequencer to not include any transactions
 	// from the transaction pool.
-	nextL2Time := l2Head.Time + d.Config.BlockTime
-	shouldProduceEmptyBlock := nextL2Time >= l1Origin.Time+d.Config.MaxSequencerDrift
-
-	// Put together our payload attributes.
-	attrs := &eth.PayloadAttributes{
-		Timestamp:             hexutil.Uint64(nextL2Time),
-		PrevRandao:            eth.Bytes32(l1Info.MixDigest()),
-		SuggestedFeeRecipient: d.Config.FeeRecipientAddress,
-		Transactions:          txns,
-		NoTxPool:              shouldProduceEmptyBlock,
-	}
+	attrs.NoTxPool = uint64(attrs.Timestamp) >= l1Origin.Time+d.Config.MaxSequencerDrift
 
 	// And construct our fork choice state. This is our current fork choice state and will be
 	// updated as a result of executing the block based on the attributes described above.

op-node/testutils/mock_l1.go

@@ -13,6 +13,15 @@ type MockL1Source struct {
 	mock.Mock
 }
 
+func (m *MockL1Source) InfoByHash(ctx context.Context, hash common.Hash) (eth.L1Info, error) {
+	out := m.Mock.MethodCalled("InfoByHash", hash)
+	return *out[0].(*eth.L1Info), *out[1].(*error)
+}
+
+func (m *MockL1Source) ExpectInfoByHash(hash common.Hash, info eth.L1Info, err error) {
+	m.Mock.On("InfoByHash", hash).Once().Return(&info, &err)
+}
+
 func (m *MockL1Source) L1BlockRefByNumber(ctx context.Context, u uint64) (eth.L1BlockRef, error) {
 	out := m.Mock.MethodCalled("L1BlockRefByNumber", u)
 	return out[0].(eth.L1BlockRef), *out[1].(*error)
@@ -33,11 +42,11 @@ func (m *MockL1Source) ExpectL1BlockRefByHash(hash common.Hash, ref eth.L1BlockR
 
 func (m *MockL1Source) Fetch(ctx context.Context, blockHash common.Hash) (eth.L1Info, types.Transactions, types.Receipts, error) {
 	out := m.Mock.MethodCalled("Fetch", blockHash)
-	return out[0].(eth.L1Info), out[1].(types.Transactions), out[2].(types.Receipts), *out[3].(*error)
+	return *out[0].(*eth.L1Info), out[1].(types.Transactions), out[2].(types.Receipts), *out[3].(*error)
 }
 
 func (m *MockL1Source) ExpectFetch(hash common.Hash, info eth.L1Info, transactions types.Transactions, receipts types.Receipts, err error) {
-	m.Mock.On("Fetch", hash).Once().Return(info, transactions, receipts, &err)
+	m.Mock.On("Fetch", hash).Once().Return(&info, transactions, receipts, &err)
 }
 
 func (m *MockL1Source) InfoAndTxsByHash(ctx context.Context, hash common.Hash) (eth.L1Info, types.Transactions, error) {