Merge pull request #3722 from ethereum-optimism/develop

Develop -> Master

.changeset/flat-windows-trade.md

+---
+'@eth-optimism/proxyd': minor
+---
+
+Allow disabling backend rate limiter

.changeset/shy-trainers-sneeze.md

+---
+'@eth-optimism/proxyd': minor
+---
+
+Support pattern matching in exempt origins/user agents

.changeset/wet-cameras-cover.md

+---
+'@eth-optimism/proxyd': minor
+---
+
+adds server.log_level config

op-e2e/actions/l1_miner.go

@@ -106,6 +106,7 @@ func (s *L1Miner) ActL1IncludeTx(from common.Address) Action {
 			return
 		}
 		s.pendingIndices[from] = i + 1 // won't retry the tx
+		s.l1BuildingState.Prepare(tx.Hash(), len(s.l1Transactions))
 		receipt, err := core.ApplyTransaction(s.l1Cfg.Config, s.l1Chain, &s.l1BuildingHeader.Coinbase,
 			s.l1GasPool, s.l1BuildingState, s.l1BuildingHeader, tx, &s.l1BuildingHeader.GasUsed, *s.l1Chain.GetVMConfig())
 		if err != nil {

op-e2e/actions/l2_batcher.go

+package actions
+
+import (
+	"bytes"
+	"context"
+	"crypto/ecdsa"
+	"io"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+type SyncStatusAPI interface {
+	SyncStatus(ctx context.Context) (*eth.SyncStatus, error)
+}
+
+type BlocksAPI interface {
+	BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
+}
+
+type L1TxAPI interface {
+	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+	SendTransaction(ctx context.Context, tx *types.Transaction) error
+}
+
+type BatcherCfg struct {
+	// Limit the size of txs
+	MinL1TxSize uint64
+	MaxL1TxSize uint64
+
+	BatcherKey *ecdsa.PrivateKey
+}
+
+// L2Batcher buffers and submits L2 batches to L1.
+//
+// TODO: note the batcher shares little logic/state with actual op-batcher,
+// tests should only use this actor to build batch contents for rollup node actors to consume,
+// until the op-batcher is refactored and can be covered better.
+type L2Batcher struct {
+	log log.Logger
+
+	rollupCfg *rollup.Config
+
+	syncStatusAPI SyncStatusAPI
+	l2            BlocksAPI
+	l1            L1TxAPI
+
+	l1Signer types.Signer
+
+	l2ChannelOut     *derive.ChannelOut
+	l2Submitting     bool // when the channel out is being submitted, and not safe to write to without resetting
+	l2BufferedBlock  eth.BlockID
+	l2SubmittedBlock eth.BlockID
+	l2BatcherCfg     *BatcherCfg
+}
+
+func NewL2Batcher(log log.Logger, rollupCfg *rollup.Config, batcherCfg *BatcherCfg, api SyncStatusAPI, l1 L1TxAPI, l2 BlocksAPI) *L2Batcher {
+	return &L2Batcher{
+		log:           log,
+		rollupCfg:     rollupCfg,
+		syncStatusAPI: api,
+		l1:            l1,
+		l2:            l2,
+		l2BatcherCfg:  batcherCfg,
+		l1Signer:      types.LatestSignerForChainID(rollupCfg.L1ChainID),
+	}
+}
+
+// SubmittingData indicates if the actor is submitting buffer data.
+// All data must be submitted before it can safely continue buffering more L2 blocks.
+func (s *L2Batcher) SubmittingData() bool {
+	return s.l2Submitting
+}
+
+// ActL2BatchBuffer adds the next L2 block to the batch buffer.
+// If the buffer is being submitted, the buffer is wiped.
+func (s *L2Batcher) ActL2BatchBuffer(t Testing) {
+	if s.l2Submitting { // break ongoing submitting work if necessary
+		s.l2ChannelOut = nil
+		s.l2Submitting = false
+	}
+	syncStatus, err := s.syncStatusAPI.SyncStatus(t.Ctx())
+	require.NoError(t, err, "no sync status error")
+	// If we just started, start at safe-head
+	if s.l2SubmittedBlock == (eth.BlockID{}) {
+		s.log.Info("Starting batch-submitter work at safe-head", "safe", syncStatus.SafeL2)
+		s.l2SubmittedBlock = syncStatus.SafeL2.ID()
+		s.l2BufferedBlock = syncStatus.SafeL2.ID()
+		s.l2ChannelOut = nil
+	}
+	// If it's lagging behind, catch it up.
+	if s.l2SubmittedBlock.Number < syncStatus.SafeL2.Number {
+		s.log.Warn("last submitted block lagged behind L2 safe head: batch submission will continue from the safe head now", "last", s.l2SubmittedBlock, "safe", syncStatus.SafeL2)
+		s.l2SubmittedBlock = syncStatus.SafeL2.ID()
+		s.l2BufferedBlock = syncStatus.SafeL2.ID()
+		s.l2ChannelOut = nil
+	}
+	// Create channel if we don't have one yet
+	if s.l2ChannelOut == nil {
+		ch, err := derive.NewChannelOut()
+		require.NoError(t, err, "failed to create channel")
+		s.l2ChannelOut = ch
+	}
+	// Add the next unsafe block to the channel
+	if s.l2BufferedBlock.Number >= syncStatus.UnsafeL2.Number {
+		return
+	}
+	block, err := s.l2.BlockByNumber(t.Ctx(), big.NewInt(int64(s.l2BufferedBlock.Number+1)))
+	require.NoError(t, err, "need l2 block %d from sync status", s.l2SubmittedBlock.Number+1)
+	if block.ParentHash() != s.l2BufferedBlock.Hash {
+		s.log.Error("detected a reorg in L2 chain vs previous submitted information, resetting to safe head now", "safe_head", syncStatus.SafeL2)
+		s.l2SubmittedBlock = syncStatus.SafeL2.ID()
+		s.l2BufferedBlock = syncStatus.SafeL2.ID()
+		s.l2ChannelOut = nil
+	}
+	if err := s.l2ChannelOut.AddBlock(block); err != nil { // should always succeed
+		t.Fatalf("failed to add block to channel: %v", err)
+	}
+}
+
+func (s *L2Batcher) ActL2ChannelClose(t Testing) {
+	// Don't run this action if there's no data to submit
+	if s.l2ChannelOut == nil {
+		t.InvalidAction("need to buffer data first, cannot batch submit with empty buffer")
+		return
+	}
+	require.NoError(t, s.l2ChannelOut.Close(), "must close channel before submitting it")
+}
+
+// ActL2BatchSubmit constructs a batch tx from previous buffered L2 blocks, and submits it to L1
+func (s *L2Batcher) ActL2BatchSubmit(t Testing) {
+	// Don't run this action if there's no data to submit
+	if s.l2ChannelOut == nil {
+		t.InvalidAction("need to buffer data first, cannot batch submit with empty buffer")
+		return
+	}
+	// Collect the output frame
+	data := new(bytes.Buffer)
+	data.WriteByte(derive.DerivationVersion0)
+	// subtract one, to account for the version byte
+	if err := s.l2ChannelOut.OutputFrame(data, s.l2BatcherCfg.MaxL1TxSize-1); err == io.EOF {
+		s.l2Submitting = false
+		// there may still be some data to submit
+	} else if err != nil {
+		s.l2Submitting = false
+		t.Fatalf("failed to output channel data to frame: %v", err)
+	}
+
+	nonce, err := s.l1.PendingNonceAt(t.Ctx(), s.rollupCfg.BatchSenderAddress)
+	require.NoError(t, err, "need batcher nonce")
+
+	gasTipCap := big.NewInt(2 * params.GWei)
+	pendingHeader, err := s.l1.HeaderByNumber(t.Ctx(), big.NewInt(-1))
+	require.NoError(t, err, "need l1 pending header for gas price estimation")
+	gasFeeCap := new(big.Int).Add(gasTipCap, new(big.Int).Mul(pendingHeader.BaseFee, big.NewInt(2)))
+
+	rawTx := &types.DynamicFeeTx{
+		ChainID:   s.rollupCfg.L1ChainID,
+		Nonce:     nonce,
+		To:        &s.rollupCfg.BatchInboxAddress,
+		GasTipCap: gasTipCap,
+		GasFeeCap: gasFeeCap,
+		Data:      data.Bytes(),
+	}
+	gas, err := core.IntrinsicGas(rawTx.Data, nil, false, true, true)
+	require.NoError(t, err, "need to compute intrinsic gas")
+	rawTx.Gas = gas
+
+	tx, err := types.SignNewTx(s.l2BatcherCfg.BatcherKey, s.l1Signer, rawTx)
+	require.NoError(t, err, "need to sign tx")
+
+	err = s.l1.SendTransaction(t.Ctx(), tx)
+	require.NoError(t, err, "need to send tx")
+}

op-e2e/actions/l2_batcher_test.go

+package actions
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBatcher(gt *testing.T) {
+	t := NewDefaultTesting(gt)
+	p := &e2eutils.TestParams{
+		MaxSequencerDrift:   20, // larger than L1 block time we simulate in this test (12)
+		SequencerWindowSize: 24,
+		ChannelTimeout:      20,
+	}
+	dp := e2eutils.MakeDeployParams(t, p)
+	sd := e2eutils.Setup(t, dp, defaultAlloc)
+	log := testlog.Logger(t, log.LvlDebug)
+	miner, seqEngine, sequencer := setupSequencerTest(t, sd, log)
+	verifEngine, verifier := setupVerifier(t, sd, log, miner.L1Client(t, sd.RollupCfg))
+
+	rollupSeqCl := sequencer.RollupClient()
+	batcher := NewL2Batcher(log, sd.RollupCfg, &BatcherCfg{
+		MinL1TxSize: 0,
+		MaxL1TxSize: 128_000,
+		BatcherKey:  dp.Secrets.Batcher,
+	}, rollupSeqCl, miner.EthClient(), seqEngine.EthClient())
+
+	// Alice makes a L2 tx
+	cl := seqEngine.EthClient()
+	n, err := cl.PendingNonceAt(t.Ctx(), dp.Addresses.Alice)
+	require.NoError(t, err)
+	signer := types.LatestSigner(sd.L2Cfg.Config)
+	tx := types.MustSignNewTx(dp.Secrets.Alice, signer, &types.DynamicFeeTx{
+		ChainID:   sd.L2Cfg.Config.ChainID,
+		Nonce:     n,
+		GasTipCap: big.NewInt(2 * params.GWei),
+		GasFeeCap: new(big.Int).Add(miner.l1Chain.CurrentBlock().BaseFee(), big.NewInt(2*params.GWei)),
+		Gas:       params.TxGas,
+		To:        &dp.Addresses.Bob,
+		Value:     e2eutils.Ether(2),
+	})
+	require.NoError(gt, cl.SendTransaction(t.Ctx(), tx))
+
+	sequencer.ActL2PipelineFull(t)
+	verifier.ActL2PipelineFull(t)
+
+	// Make L2 block
+	sequencer.ActL2StartBlock(t)
+	seqEngine.ActL2IncludeTx(dp.Addresses.Alice)(t)
+	sequencer.ActL2EndBlock(t)
+
+	// batch submit to L1
+	batcher.ActL2BatchBuffer(t)
+	batcher.ActL2ChannelClose(t)
+	batcher.ActL2BatchSubmit(t)
+
+	// confirm batch on L1
+	miner.ActL1StartBlock(12)(t)
+	miner.ActL1IncludeTx(dp.Addresses.Batcher)(t)
+	miner.ActL1EndBlock(t)
+	bl := miner.l1Chain.CurrentBlock()
+	log.Info("bl", "txs", len(bl.Transactions()))
+
+	// Now make enough L1 blocks that the verifier will have to derive a L2 block
+	for i := uint64(1); i < sd.RollupCfg.SeqWindowSize; i++ {
+		miner.ActL1StartBlock(12)(t)
+		miner.ActL1EndBlock(t)
+	}
+
+	// sync verifier from L1 batch in otherwise empty sequence window
+	verifier.ActL1HeadSignal(t)
+	verifier.ActL2PipelineFull(t)
+	require.Equal(t, uint64(1), verifier.SyncStatus().SafeL2.L1Origin.Number)
+
+	// check that the tx from alice made it into the L2 chain
+	verifCl := verifEngine.EthClient()
+	vTx, isPending, err := verifCl.TransactionByHash(t.Ctx(), tx.Hash())
+	require.NoError(t, err)
+	require.False(t, isPending)
+	require.NotNil(t, vTx)
+}

op-e2e/actions/l2_engine.go

@@ -174,6 +174,7 @@ func (e *L2Engine) ActL2IncludeTx(from common.Address) Action {
 			return
 		}
 		e.pendingIndices[from] = i + 1 // won't retry the tx
+		e.l2BuildingState.Prepare(tx.Hash(), len(e.l2Transactions))
 		receipt, err := core.ApplyTransaction(e.l2Cfg.Config, e.l2Chain, &e.l2BuildingHeader.Coinbase,
 			e.l2GasPool, e.l2BuildingState, e.l2BuildingHeader, tx, &e.l2BuildingHeader.GasUsed, *e.l2Chain.GetVMConfig())
 		if err != nil {

op-e2e/actions/user_test.go

+package actions
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
+)
+
+func TestCrossLayerUser(gt *testing.T) {
+	t := NewDefaultTesting(gt)
+	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	sd := e2eutils.Setup(t, dp, defaultAlloc)
+	log := testlog.Logger(t, log.LvlDebug)
+
+	miner, seqEngine, seq := setupSequencerTest(t, sd, log)
+
+	// need to start derivation before we can make L2 blocks
+	seq.ActL2PipelineFull(t)
+
+	l1Cl := miner.EthClient()
+	l2Cl := seqEngine.EthClient()
+	withdrawalsCl := &withdrawals.Client{} // TODO: need a rollup node actor to wrap for output root proof RPC
+
+	addresses := e2eutils.CollectAddresses(sd, dp)
+
+	l1UserEnv := &BasicUserEnv[*L1Bindings]{
+		EthCl:          l1Cl,
+		Signer:         types.LatestSigner(sd.L1Cfg.Config),
+		AddressCorpora: addresses,
+		Bindings:       NewL1Bindings(t, l1Cl, &sd.DeploymentsL1),
+	}
+	l2UserEnv := &BasicUserEnv[*L2Bindings]{
+		EthCl:          l2Cl,
+		Signer:         types.LatestSigner(sd.L2Cfg.Config),
+		AddressCorpora: addresses,
+		Bindings:       NewL2Bindings(t, l2Cl, withdrawalsCl),
+	}
+
+	alice := NewCrossLayerUser(log, dp.Secrets.Alice, rand.New(rand.NewSource(1234)))
+	alice.L1.SetUserEnv(l1UserEnv)
+	alice.L2.SetUserEnv(l2UserEnv)
+
+	// regular L2 tx, in new L2 block
+	alice.L2.ActResetTxOpts(t)
+	alice.L2.ActSetTxToAddr(&dp.Addresses.Bob)(t)
+	alice.L2.ActMakeTx(t)
+	seq.ActL2StartBlock(t)
+	seqEngine.ActL2IncludeTx(alice.Address())(t)
+	seq.ActL2EndBlock(t)
+	alice.L2.ActCheckReceiptStatusOfLastTx(true)(t)
+
+	// regular L1 tx, in new L1 block
+	alice.L1.ActResetTxOpts(t)
+	alice.L1.ActSetTxToAddr(&dp.Addresses.Bob)(t)
+	alice.L1.ActMakeTx(t)
+	miner.ActL1StartBlock(12)(t)
+	miner.ActL1IncludeTx(alice.Address())(t)
+	miner.ActL1EndBlock(t)
+	alice.L1.ActCheckReceiptStatusOfLastTx(true)(t)
+
+	// regular Deposit, in new L1 block
+	alice.ActDeposit(t)
+	miner.ActL1StartBlock(12)(t)
+	miner.ActL1IncludeTx(alice.Address())(t)
+	miner.ActL1EndBlock(t)
+
+	seq.ActL1HeadSignal(t)
+
+	// sync sequencer build enough blocks to adopt latest L1 origin
+	for seq.SyncStatus().UnsafeL2.L1Origin.Number < miner.l1Chain.CurrentBlock().NumberU64() {
+		seq.ActL2StartBlock(t)
+		seq.ActL2EndBlock(t)
+	}
+	// Now that the L2 chain adopted the latest L1 block, check that we processed the deposit
+	alice.ActCheckDepositStatus(true, true)(t)
+}

op-node/client/rpc.go

@@ -43,7 +43,7 @@ func NewRPC(ctx context.Context, lgr log.Logger, addr string, opts ...rpc.Client
 func DialRPCClientWithBackoff(ctx context.Context, log log.Logger, addr string, opts ...rpc.ClientOption) (*rpc.Client, error) {
 	bOff := backoff.Exponential()
 	var ret *rpc.Client
-	err := backoff.Do(10, bOff, func() error {
+	err := backoff.DoCtx(ctx, 10, bOff, func() error {
 		client, err := rpc.DialOptions(ctx, addr, opts...)
 		if err != nil {
 			if client == nil {

op-node/eth/block_info.go

@@ -4,8 +4,11 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 )
 
+var _ BlockInfo = (&types.Block{})
+
 type BlockInfo interface {
 	Hash() common.Hash
 	ParentHash() common.Hash
@@ -16,7 +19,6 @@ type BlockInfo interface {
 	// MixDigest field, reused for randomness after The Merge (Bellatrix hardfork)
 	MixDigest() common.Hash
 	BaseFee() *big.Int
-	ID() BlockID
 	ReceiptHash() common.Hash
 }
 
@@ -28,3 +30,15 @@ func InfoToL1BlockRef(info BlockInfo) L1BlockRef {
 		Time:       info.Time(),
 	}
 }
+
+type NumberAndHash interface {
+	Hash() common.Hash
+	NumberU64() uint64
+}
+
+func ToBlockID(b NumberAndHash) BlockID {
+	return BlockID{
+		Hash:   b.Hash(),
+		Number: b.NumberU64(),
+	}
+}

op-node/rollup/derive/batch_queue.go

@@ -59,7 +59,11 @@ func (bq *BatchQueue) Origin() eth.L1BlockRef {
 }
 
 func (bq *BatchQueue) NextBatch(ctx context.Context, safeL2Head eth.L2BlockRef) (*BatchData, error) {
-	originBehind := bq.origin.Number < safeL2Head.L1Origin.Number
+	// Note: We use the origin that we will have to determine if it's behind. This is important
+	// because it's the future origin that gets saved into the l1Blocks array.
+	// We always update the origin of this stage if it is not the same so after the update code
+	// runs, this is consistent.
+	originBehind := bq.prev.Origin().Number < safeL2Head.L1Origin.Number
 
 	// Advance origin if needed
 	// Note: The entire pipeline has the same origin

op-node/rollup/derive/engine_queue.go

@@ -405,7 +405,7 @@ func (eq *EngineQueue) forceNextSafeAttributes(ctx context.Context) error {
 // ResetStep Walks the L2 chain backwards until it finds an L2 block whose L1 origin is canonical.
 // The unsafe head is set to the head of the L2 chain, unless the existing safe head is not canonical.
 func (eq *EngineQueue) Reset(ctx context.Context, _ eth.L1BlockRef) error {
-	result, err := sync.FindL2Heads(ctx, eq.cfg, eq.l1Fetcher, eq.engine)
+	result, err := sync.FindL2Heads(ctx, eq.cfg, eq.l1Fetcher, eq.engine, eq.log)
 	if err != nil {
 		return NewTemporaryError(fmt.Errorf("failed to find the L2 Heads to start from: %w", err))
 	}

op-node/rollup/driver/sequencer.go

@@ -91,6 +91,7 @@ func (d *Sequencer) CompleteBuildingBlock(ctx context.Context) (*eth.ExecutionPa
 	if err != nil {
 		return nil, fmt.Errorf("failed to complete building on top of L2 chain %s, error (%d): %w", d.buildingOnto.HeadBlockHash, errTyp, err)
 	}
+	d.buildingID = eth.PayloadID{}
 	return payload, nil
 }
 
@@ -103,7 +104,6 @@ func (d *Sequencer) CreateNewBlock(ctx context.Context, l2Head eth.L2BlockRef, l
 	if err != nil {
 		return l2Head, nil, err
 	}
-	d.buildingID = eth.PayloadID{}
 
 	// Generate an L2 block ref from the payload.
 	ref, err := derive.PayloadToBlockRef(payload, &d.config.Genesis)

op-node/rollup/driver/state.go

@@ -266,7 +266,7 @@ func (s *Driver) eventLoop() {
 				s.log.Warn("not creating block, node is deriving new l2 data", "head_l1", l1Head)
 				break
 			}
-			ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+			ctx, cancel := context.WithTimeout(ctx, 20*time.Minute)
 			err := s.createNewL2Block(ctx)
 			cancel()
 			if err != nil {
@@ -309,9 +309,7 @@ func (s *Driver) eventLoop() {
 			s.metrics.SetDerivationIdle(false)
 			s.idleDerivation = false
 			s.log.Debug("Derivation process step", "onto_origin", s.derivation.Origin(), "attempts", stepAttempts)
-			stepCtx, cancel := context.WithTimeout(ctx, time.Second*10) // TODO pick a timeout for executing a single step
-			err := s.derivation.Step(stepCtx)
-			cancel()
+			err := s.derivation.Step(context.Background())
 			stepAttempts += 1 // count as attempt by default. We reset to 0 if we are making healthy progress.
 			if err == io.EOF {
 				s.log.Debug("Derivation process went idle", "progress", s.derivation.Origin())

op-node/rollup/sync/start.go

@@ -32,6 +32,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
 )
 
 type L1Chain interface {
@@ -101,7 +102,7 @@ func currentHeads(ctx context.Context, cfg *rollup.Config, l2 L2Chain) (*FindHea
 // Plausible: meaning that the blockhash of the L2 block's L1 origin
 // (as reported in the L1 Attributes deposit within the L2 block) is not canonical at another height in the L1 chain,
 // and the same holds for all its ancestors.
-func FindL2Heads(ctx context.Context, cfg *rollup.Config, l1 L1Chain, l2 L2Chain) (result *FindHeadsResult, err error) {
+func FindL2Heads(ctx context.Context, cfg *rollup.Config, l1 L1Chain, l2 L2Chain, lgr log.Logger) (result *FindHeadsResult, err error) {
 	// Fetch current L2 forkchoice state
 	result, err = currentHeads(ctx, cfg, l2)
 	if err != nil {
@@ -137,6 +138,8 @@ func FindL2Heads(ctx context.Context, cfg *rollup.Config, l1 L1Chain, l2 L2Chain
 			ahead = notFound
 		}
 
+		lgr.Trace("walking sync start", "number", n.Number)
+
 		// Don't walk past genesis. If we were at the L2 genesis, but could not find its L1 origin,
 		// the L2 chain is building on the wrong L1 branch.
 		if n.Number == cfg.Genesis.L2.Number {

op-node/rollup/sync/start_test.go

@@ -73,7 +73,9 @@ func (c *syncStartTestCase) Run(t *testing.T) {
 		Genesis:       genesis,
 		SeqWindowSize: c.SeqWindowSize,
 	}
-	result, err := FindL2Heads(context.Background(), cfg, chain, chain)
+	lgr := log.New()
+	lgr.SetHandler(log.DiscardHandler())
+	result, err := FindL2Heads(context.Background(), cfg, chain, chain, lgr)
 	if c.ExpectedErr != nil {
 		require.ErrorIs(t, err, c.ExpectedErr, "expected error")
 		return

op-node/sources/eth_client.go

@@ -251,7 +251,7 @@ func (s *EthClient) FetchReceipts(ctx context.Context, blockHash common.Hash) (e
 		for i := 0; i < len(txs); i++ {
 			txHashes[i] = txs[i].Hash()
 		}
-		fetcher = NewReceiptsFetcher(info.ID(), info.ReceiptHash(), txHashes, s.client.BatchCallContext, s.maxBatchSize)
+		fetcher = NewReceiptsFetcher(eth.ToBlockID(info), info.ReceiptHash(), txHashes, s.client.BatchCallContext, s.maxBatchSize)
 		s.receiptsCache.Add(blockHash, fetcher)
 	}
 	// Fetch all receipts

packages/contracts-bedrock/deploy/001-InitImplementations.deploy.ts

@@ -7,7 +7,7 @@ import '@eth-optimism/hardhat-deploy-config'
 
 const upgradeABIs = {
   L2OutputOracleProxy: async (deployConfig) => [
-    'initialize(bytes32,uint256,address,address)',
+    'initialize(bytes32,uint256,address)',
     [
       deployConfig.l2OutputOracleGenesisL2Output,
       deployConfig.l2OutputOracleProposer,

proxyd/backend_rate_limiter.go

@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"math"
 	"sync"
 	"time"
 
@@ -256,5 +257,30 @@ func randStr(l int) string {
 	return hex.EncodeToString(b)
 }
 
-type ServerRateLimiter struct {
+type NoopBackendRateLimiter struct{}
+
+var noopBackendRateLimiter = &NoopBackendRateLimiter{}
+
+func (n *NoopBackendRateLimiter) IsBackendOnline(name string) (bool, error) {
+	return true, nil
+}
+
+func (n *NoopBackendRateLimiter) SetBackendOffline(name string, duration time.Duration) error {
+	return nil
+}
+
+func (n *NoopBackendRateLimiter) IncBackendRPS(name string) (int, error) {
+	return math.MaxInt, nil
+}
+
+func (n *NoopBackendRateLimiter) IncBackendWSConns(name string, max int) (bool, error) {
+	return true, nil
+}
+
+func (n *NoopBackendRateLimiter) DecBackendWSConns(name string) error {
+	return nil
+}
+
+func (n *NoopBackendRateLimiter) FlushBackendWSConns(names []string) error {
+	return nil
 }

proxyd/cmd/proxyd/main.go

@@ -37,6 +37,21 @@ func main() {
 		log.Crit("error reading config file", "err", err)
 	}
 
+	// update log level from config
+	logLevel, err := log.LvlFromString(config.Server.LogLevel)
+	if err != nil {
+		logLevel = log.LvlInfo
+		if config.Server.LogLevel != "" {
+			log.Warn("invalid server.log_level set: " + config.Server.LogLevel)
+		}
+	}
+	log.Root().SetHandler(
+		log.LvlFilterHandler(
+			logLevel,
+			log.StreamHandler(os.Stdout, log.JSONFormat()),
+		),
+	)
+
 	shutdown, err := proxyd.Start(config)
 	if err != nil {
 		log.Crit("error starting proxyd", "err", err)

proxyd/config.go

@@ -14,6 +14,7 @@ type ServerConfig struct {
 	WSPort            int    `toml:"ws_port"`
 	MaxBodySizeBytes  int64  `toml:"max_body_size_bytes"`
 	MaxConcurrentRPCs int64  `toml:"max_concurrent_rpcs"`
+	LogLevel          string `toml:"log_level"`
 
 	// TimeoutSeconds specifies the maximum time spent serving an HTTP request. Note that isn't used for websocket connections
 	TimeoutSeconds int `toml:"timeout_seconds"`
@@ -41,13 +42,14 @@ type MetricsConfig struct {
 }
 
 type RateLimitConfig struct {
-	UseRedis         bool                                `toml:"use_redis"`
-	BaseRate         int                                 `toml:"base_rate"`
-	BaseInterval     TOMLDuration                        `toml:"base_interval"`
-	ExemptOrigins    []string                            `toml:"exempt_origins"`
-	ExemptUserAgents []string                            `toml:"exempt_user_agents"`
-	ErrorMessage     string                              `toml:"error_message"`
-	MethodOverrides  map[string]*RateLimitMethodOverride `toml:"method_overrides"`
+	UseRedis                 bool                                `toml:"use_redis"`
+	EnableBackendRateLimiter bool                                `toml:"enable_backend_rate_limiter"`
+	BaseRate                 int                                 `toml:"base_rate"`
+	BaseInterval             TOMLDuration                        `toml:"base_interval"`
+	ExemptOrigins            []string                            `toml:"exempt_origins"`
+	ExemptUserAgents         []string                            `toml:"exempt_user_agents"`
+	ErrorMessage             string                              `toml:"error_message"`
+	MethodOverrides          map[string]*RateLimitMethodOverride `toml:"method_overrides"`
 }
 
 type RateLimitMethodOverride struct {

proxyd/example.config.toml

@@ -19,6 +19,8 @@ ws_port = 8085
 # Maximum client body size, in bytes, that the server will accept.
 max_body_size_bytes = 10485760
 max_concurrent_rpcs = 1000
+# Server log level
+log_level = "info"
 
 [redis]
 # URL to a Redis instance.

proxyd/integration_tests/testdata/backend_rate_limit.toml

@@ -15,4 +15,7 @@ max_rps = 2
 backends = ["good"]
 
 [rpc_method_mappings]
-eth_chainId = "main"
\ No newline at end of file
+eth_chainId = "main"
+
+[rate_limit]
+enable_backend_rate_limiter = true
\ No newline at end of file

proxyd/integration_tests/testdata/out_of_service_interval.toml

@@ -19,4 +19,7 @@ ws_url = "$BAD_BACKEND_RPC_URL"
 backends = ["bad", "good"]
 
 [rpc_method_mappings]
-eth_chainId = "main"
\ No newline at end of file
+eth_chainId = "main"
+
+[rate_limit]
+enable_backend_rate_limiter = true
\ No newline at end of file

proxyd/integration_tests/testdata/ws.toml

@@ -26,3 +26,6 @@ backends = ["good"]
 
 [rpc_method_mappings]
 eth_chainId = "main"
+
+[rate_limit]
+enable_backend_rate_limiter = true
\ No newline at end of file

proxyd/proxyd.go

@@ -53,11 +53,15 @@ func Start(config *Config) (func(), error) {
 
 	var lim BackendRateLimiter
 	var err error
-	if redisClient == nil {
-		log.Warn("redis is not configured, using local rate limiter")
-		lim = NewLocalBackendRateLimiter()
+	if config.RateLimit.EnableBackendRateLimiter {
+		if redisClient != nil {
+			lim = NewRedisRateLimiter(redisClient)
+		} else {
+			log.Warn("redis is not configured, using local rate limiter")
+			lim = NewLocalBackendRateLimiter()
+		}
 	} else {
-		lim = NewRedisRateLimiter(redisClient)
+		lim = noopBackendRateLimiter
 	}
 
 	// While modifying shared globals is a bad practice, the alternative

proxyd/server.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"math"
 	"net/http"
+	"regexp"
 	"strconv"
 	"strings"
 	"sync"
@@ -49,8 +50,8 @@ type Server struct {
 	upgrader             *websocket.Upgrader
 	mainLim              FrontendRateLimiter
 	overrideLims         map[string]FrontendRateLimiter
-	limExemptOrigins     map[string]bool
-	limExemptUserAgents  map[string]bool
+	limExemptOrigins     []*regexp.Regexp
+	limExemptUserAgents  []*regexp.Regexp
 	rpcServer            *http.Server
 	wsServer             *http.Server
 	cache                RPCCache
@@ -104,15 +105,23 @@ func NewServer(
 	}
 
 	var mainLim FrontendRateLimiter
-	limExemptOrigins := make(map[string]bool)
-	limExemptUserAgents := make(map[string]bool)
+	limExemptOrigins := make([]*regexp.Regexp, 0)
+	limExemptUserAgents := make([]*regexp.Regexp, 0)
 	if rateLimitConfig.BaseRate > 0 {
 		mainLim = limiterFactory(time.Duration(rateLimitConfig.BaseInterval), rateLimitConfig.BaseRate, "main")
 		for _, origin := range rateLimitConfig.ExemptOrigins {
-			limExemptOrigins[strings.ToLower(origin)] = true
+			pattern, err := regexp.Compile(origin)
+			if err != nil {
+				return nil, err
+			}
+			limExemptOrigins = append(limExemptOrigins, pattern)
 		}
 		for _, agent := range rateLimitConfig.ExemptUserAgents {
-			limExemptUserAgents[strings.ToLower(agent)] = true
+			pattern, err := regexp.Compile(agent)
+			if err != nil {
+				return nil, err
+			}
+			limExemptUserAgents = append(limExemptUserAgents, pattern)
 		}
 	} else {
 		mainLim = NoopFrontendRateLimiter
@@ -548,11 +557,22 @@ func (s *Server) populateContext(w http.ResponseWriter, r *http.Request) context
 }
 
 func (s *Server) isUnlimitedOrigin(origin string) bool {
-	return s.limExemptOrigins[strings.ToLower(origin)]
+	for _, pat := range s.limExemptOrigins {
+		if pat.MatchString(origin) {
+			return true
+		}
+	}
+
+	return false
 }
 
 func (s *Server) isUnlimitedUserAgent(origin string) bool {
-	return s.limExemptUserAgents[strings.ToLower(origin)]
+	for _, pat := range s.limExemptUserAgents {
+		if pat.MatchString(origin) {
+			return true
+		}
+	}
+	return false
 }
 
 func setCacheHeader(w http.ResponseWriter, cached bool) {