Merge branch 'develop' into aj/simple-trace-accessor

.circleci/config.yml

@@ -1420,13 +1420,6 @@ workflows:
             - op-stack-go-lint
             - devnet-allocs
             - l1-geth-version-check
-      - go-e2e-test:
-          name: op-e2e-span-batch-tests
-          module: op-e2e
-          target: test-span-batch
-          requires:
-            - op-stack-go-lint
-            - devnet-allocs
       - op-program-compat:
           requires:
             - op-program-tests

op-chain-ops/cmd/check-canyon/main.go

+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"math/big"
+	"os"
+
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-service/client"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/optimism/op-service/sources"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/trie"
+)
+
+func CalcBaseFee(parent eth.BlockInfo, elasticity uint64, canyonActive bool) *big.Int {
+	denomUint := uint64(50)
+	if canyonActive {
+		denomUint = uint64(250)
+	}
+	parentGasTarget := parent.GasLimit() / elasticity
+	// If the parent gasUsed is the same as the target, the baseFee remains unchanged.
+	if parent.GasUsed() == parentGasTarget {
+		return new(big.Int).Set(parent.BaseFee())
+	}
+
+	var (
+		num   = new(big.Int)
+		denom = new(big.Int)
+	)
+
+	if parent.GasUsed() > parentGasTarget {
+		// If the parent block used more gas than its target, the baseFee should increase.
+		// max(1, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator)
+		num.SetUint64(parent.GasUsed() - parentGasTarget)
+		num.Mul(num, parent.BaseFee())
+		num.Div(num, denom.SetUint64(parentGasTarget))
+		num.Div(num, denom.SetUint64(denomUint))
+		baseFeeDelta := math.BigMax(num, common.Big1)
+
+		return num.Add(parent.BaseFee(), baseFeeDelta)
+	} else {
+		// Otherwise if the parent block used less gas than its target, the baseFee should decrease.
+		// max(0, parentBaseFee * gasUsedDelta / parentGasTarget / baseFeeChangeDenominator)
+		num.SetUint64(parentGasTarget - parent.GasUsed())
+		num.Mul(num, parent.BaseFee())
+		num.Div(num, denom.SetUint64(parentGasTarget))
+		num.Div(num, denom.SetUint64(denomUint))
+		baseFee := num.Sub(parent.BaseFee(), num)
+
+		return math.BigMax(baseFee, common.Big0)
+	}
+}
+
+func ManuallyEncodeReceipts(receipts types.Receipts, canyonActive bool) [][]byte {
+	v := uint64(1)
+	for _, receipt := range receipts {
+		if receipt.Type == types.DepositTxType {
+			if canyonActive {
+				receipt.DepositReceiptVersion = &v
+			} else {
+				receipt.DepositReceiptVersion = nil
+			}
+
+		}
+	}
+	var out [][]byte
+	for i := range receipts {
+		var buf bytes.Buffer
+		receipts.EncodeIndex(i, &buf)
+		out = append(out, buf.Bytes())
+	}
+	return out
+}
+
+type rawReceipts [][]byte
+
+func (s rawReceipts) Len() int { return len(s) }
+func (s rawReceipts) EncodeIndex(i int, w *bytes.Buffer) {
+	w.Write(s[i])
+}
+func HashList(list [][]byte) common.Hash {
+	hasher := trie.NewStackTrie(nil)
+	return types.DeriveSha(rawReceipts(list), hasher)
+}
+
+type L2Client interface {
+	BlockByNumber(context.Context, *big.Int) (*types.Block, error)
+	CodeAt(context.Context, common.Address, *big.Int) ([]byte, error)
+	InfoByNumber(context.Context, uint64) (eth.BlockInfo, error)
+	FetchReceipts(context.Context, common.Hash) (eth.BlockInfo, types.Receipts, error)
+}
+
+type Client struct {
+	*ethclient.Client
+	*sources.L1Client
+}
+
+type Args struct {
+	Number     uint64
+	Elasticity uint64
+	Client     L2Client
+}
+
+func ValidateReceipts(ctx Args, canyonActive bool) error {
+	block, err := ctx.Client.InfoByNumber(context.Background(), ctx.Number)
+	if err != nil {
+		return err
+	}
+
+	_, receipts, err := ctx.Client.FetchReceipts(context.Background(), block.Hash())
+	if err != nil {
+		return err
+	}
+
+	have := block.ReceiptHash()
+	want := HashList(ManuallyEncodeReceipts(receipts, canyonActive))
+
+	if have != want {
+		return fmt.Errorf("Receipts do not look correct. canyonActive: %v. have: %v, want: %v", canyonActive, have, want)
+	}
+
+	return nil
+}
+
+func Validate1559Params(ctx Args, canyonActive bool) error {
+	block, err := ctx.Client.InfoByNumber(context.Background(), ctx.Number)
+	if err != nil {
+		return err
+	}
+
+	if block.BaseFee().Cmp(big.NewInt(1000)) < 0 {
+		log.Info("Basefee to low to properly validate", "basefee", block.BaseFee())
+		return nil
+	}
+
+	parent, err := ctx.Client.InfoByNumber(context.Background(), ctx.Number-1)
+	if err != nil {
+		return err
+	}
+
+	want := CalcBaseFee(parent, ctx.Elasticity, canyonActive)
+	have := block.BaseFee()
+
+	if have.Cmp(want) != 0 {
+		return fmt.Errorf("BaseFee does not match. canyonActive: %v. have: %v, want: %v", canyonActive, have, want)
+	}
+
+	return nil
+}
+
+func ValidateWithdrawals(ctx Args, canyonActive bool) error {
+	block, err := ctx.Client.BlockByNumber(context.Background(), new(big.Int).SetUint64(ctx.Number))
+	if err != nil {
+		return err
+	}
+
+	if canyonActive && block.Withdrawals() == nil {
+		return errors.New("No nonwithdrawals in a canyon block")
+	} else if canyonActive && len(block.Withdrawals()) > 0 {
+		return errors.New("Withdrawals length is not zero in a canyon block")
+	} else if !canyonActive && block.Withdrawals() != nil {
+		return errors.New("Withdrawals in a pre-canyon block")
+	}
+	return nil
+}
+
+func ValidateCreate2Deployer(ctx Args, canyonActive bool) error {
+	addr := common.HexToAddress("0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2")
+	code, err := ctx.Client.CodeAt(context.Background(), addr, new(big.Int).SetUint64(ctx.Number))
+	if err != nil {
+		return err
+	}
+	codeHash := crypto.Keccak256Hash(code)
+	expectedCodeHash := common.HexToHash("0xb0550b5b431e30d38000efb7107aaa0ade03d48a7198a140edda9d27134468b2")
+
+	if canyonActive && codeHash != expectedCodeHash {
+		return fmt.Errorf("Canyon active but code hash does not match. have: %v, want: %v", codeHash, expectedCodeHash)
+	} else if !canyonActive && codeHash == expectedCodeHash {
+		return fmt.Errorf("Canyon not active but code hashes do match. codeHash: %v", codeHash)
+	}
+
+	return nil
+}
+
+// CheckActivation takes a function f which determines in a specific block follows the rules of a fork.
+// forkActivated tells `f` if the fork is active or not. `f` is called twice: First to validate that
+// there is no error when checking the new value and second to validate the it returns an error when
+// attempting to validate the block against the opposite of what is is.
+// If any error is encountered, valid is set to false.
+func CheckActivation(f func(Args, bool) error, ctx Args, forkActivated bool, valid *bool) {
+	if forkActivated {
+		if err := f(ctx, true); err != nil {
+			log.Error("Pre-state was invalid when it was expected to be valid", "err", err)
+			*valid = false
+		}
+		if err := f(ctx, false); err == nil {
+			log.Error("Post-state was valid when it was expected to be invalid")
+			*valid = false
+		}
+	} else {
+		if err := f(ctx, true); err == nil {
+			log.Error("Pre-state was valid when it was expected to be invalid")
+			*valid = false
+		}
+		if err := f(ctx, false); err != nil {
+			log.Error("Post-state was invalid when it was expected to be valid", "err", err)
+			*valid = false
+		}
+	}
+}
+
+func main() {
+	logger := log.New()
+
+	// Define the flag variables
+	var (
+		canyonActive bool
+		number       uint64
+		elasticity   uint64
+		rpcURL       string
+	)
+
+	valid := true
+
+	// Define and parse the command-line flags
+	flag.BoolVar(&canyonActive, "canyon", false, "Set this flag to assert canyon behavior")
+	flag.Uint64Var(&number, "number", 31, "Block number to check")
+	flag.Uint64Var(&elasticity, "elasticity", 6, "Specify the EIP-1559 elasticity. 6 on mainnet/sepolia. 10 on goerli")
+	flag.StringVar(&rpcURL, "rpc-url", "http://localhost:8545", "Specify the L2 ETH RPC URL")
+
+	// Parse the command-line arguments
+	flag.Parse()
+
+	l2RPC, err := client.NewRPC(context.Background(), logger, rpcURL, client.WithDialBackoff(10))
+	if err != nil {
+		log.Crit("Error creating RPC", "err", err)
+	}
+	c := &rollup.Config{SeqWindowSize: 10}
+	l2Cfg := sources.L1ClientDefaultConfig(c, true, sources.RPCKindBasic)
+	sourceClient, err := sources.NewL1Client(l2RPC, logger, nil, l2Cfg)
+	if err != nil {
+		log.Crit("Error creating RPC", "err", err)
+	}
+	ethClient, err := ethclient.Dial(rpcURL)
+	if err != nil {
+		log.Crit("Error creating RPC", "err", err)
+	}
+
+	client := Client{ethClient, sourceClient}
+
+	ctx := Args{
+		Number:     number,
+		Elasticity: elasticity,
+		Client:     client,
+	}
+
+	CheckActivation(ValidateReceipts, ctx, canyonActive, &valid)
+	CheckActivation(Validate1559Params, ctx, canyonActive, &valid)
+	CheckActivation(ValidateWithdrawals, ctx, canyonActive, &valid)
+	CheckActivation(ValidateCreate2Deployer, ctx, canyonActive, &valid)
+
+	if !valid {
+		os.Exit(1)
+	} else if canyonActive {
+		log.Info(fmt.Sprintf("Successfully validated block %v as a Canyon block", number))
+	} else {
+		log.Info(fmt.Sprintf("Successfully validated block %v as a Pre-Canyon block", number))
+	}
+}

op-e2e/Makefile

@@ -23,10 +23,6 @@ test-http: pre-test
 	OP_E2E_USE_HTTP=true $(go_test) $(go_test_flags) ./...
 .PHONY: test-http
 
-test-span-batch: pre-test
-	OP_E2E_USE_SPAN_BATCH=true $(go_test) $(go_test_flags) ./...
-.PHONY: test-span-batch
-
 cannon-prestate:
 	make -C .. cannon-prestate
 .PHONY: cannon-prestate

op-e2e/actions/blocktime_test.go

@@ -6,20 +6,47 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/stretchr/testify/require"
 )
 
-// TestBatchInLastPossibleBlocks tests that the derivation pipeline
+// TestBlockTimeBatchType run each blocktime-related test case in singular batch mode and span batch mode.
+func TestBlockTimeBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"BatchInLastPossibleBlocks", BatchInLastPossibleBlocks},
+		{"LargeL1Gaps", LargeL1Gaps},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
+// BatchInLastPossibleBlocks tests that the derivation pipeline
 // accepts a batch that is included in the last possible L1 block
 // where there are also no other batches included in the sequence
 // window.
 // This is a regression test against the bug fixed in PR #4566
-func TestBatchInLastPossibleBlocks(gt *testing.T) {
+func BatchInLastPossibleBlocks(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	dp.DeployConfig.SequencerWindowSize = 4
 	dp.DeployConfig.L2BlockTime = 2
 
@@ -116,7 +143,7 @@ func TestBatchInLastPossibleBlocks(gt *testing.T) {
 	verifyChainStateOnSequencer(12, 23, 11, 17, 8)
 }
 
-// TestLargeL1Gaps tests the case that there is a gap between two L1 blocks which
+// LargeL1Gaps tests the case that there is a gap between two L1 blocks which
 // is larger than the sequencer drift.
 // This test has the following parameters:
 // L1 Block time: 4s. L2 Block time: 2s. Sequencer Drift: 32s
@@ -127,13 +154,14 @@ func TestBatchInLastPossibleBlocks(gt *testing.T) {
 // Then it generates 3 more L1 blocks.
 // At this point it can verify that the batches where properly generated.
 // Note: It batches submits when possible.
-func TestLargeL1Gaps(gt *testing.T) {
+func LargeL1Gaps(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
 	dp.DeployConfig.L1BlockTime = 4
 	dp.DeployConfig.L2BlockTime = 2
 	dp.DeployConfig.SequencerWindowSize = 4
 	dp.DeployConfig.MaxSequencerDrift = 32
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 

op-e2e/actions/l2_batcher_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
@@ -20,7 +21,36 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 )
 
-func TestBatcher(gt *testing.T) {
+// TestL2BatcherBatchType run each batcher-related test case in singular batch mode and span batch mode.
+func TestL2BatcherBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"NormalBatcher", NormalBatcher},
+		{"L2Finalization", L2Finalization},
+		{"L2FinalizationWithSparseL1", L2FinalizationWithSparseL1},
+		{"GarbageBatch", GarbageBatch},
+		{"ExtendedTimeWithoutL1Batches", ExtendedTimeWithoutL1Batches},
+		{"BigL2Txs", BigL2Txs},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
+func NormalBatcher(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	p := &e2eutils.TestParams{
 		MaxSequencerDrift:   20, // larger than L1 block time we simulate in this test (12)
@@ -29,6 +59,7 @@ func TestBatcher(gt *testing.T) {
 		L1BlockTime:         12,
 	}
 	dp := e2eutils.MakeDeployParams(t, p)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, seqEngine, sequencer := setupSequencerTest(t, sd, log)
@@ -55,7 +86,7 @@ func TestBatcher(gt *testing.T) {
 		To:        &dp.Addresses.Bob,
 		Value:     e2eutils.Ether(2),
 	})
-	require.NoError(gt, cl.SendTransaction(t.Ctx(), tx))
+	require.NoError(t, cl.SendTransaction(t.Ctx(), tx))
 
 	sequencer.ActL2PipelineFull(t)
 	verifier.ActL2PipelineFull(t)
@@ -97,9 +128,10 @@ func TestBatcher(gt *testing.T) {
 	require.NotNil(t, vTx)
 }
 
-func TestL2Finalization(gt *testing.T) {
+func L2Finalization(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, engine, sequencer := setupSequencerTest(t, sd, log)
@@ -202,10 +234,11 @@ func TestL2Finalization(gt *testing.T) {
 	require.Equal(t, heightToSubmit, sequencer.SyncStatus().FinalizedL2.Number, "unknown/bad finalized L1 blocks are ignored")
 }
 
-// TestL2FinalizationWithSparseL1 tests that safe L2 blocks can be finalized even if we do not regularly get a L1 finalization signal
-func TestL2FinalizationWithSparseL1(gt *testing.T) {
+// L2FinalizationWithSparseL1 tests that safe L2 blocks can be finalized even if we do not regularly get a L1 finalization signal
+func L2FinalizationWithSparseL1(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, engine, sequencer := setupSequencerTest(t, sd, log)
@@ -258,13 +291,14 @@ func TestL2FinalizationWithSparseL1(gt *testing.T) {
 	require.Equal(t, finalStatus.FinalizedL2.Number, finalStatus.UnsafeL2.Number, "sequencer submitted its L2 block and it finalized")
 }
 
-// TestGarbageBatch tests the behavior of an invalid/malformed output channel frame containing
+// GarbageBatch tests the behavior of an invalid/malformed output channel frame containing
 // valid batches being submitted to the batch inbox. These batches should always be rejected
 // and the safe L2 head should remain unaltered.
-func TestGarbageBatch(gt *testing.T) {
+func GarbageBatch(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	p := defaultRollupTestParams
 	dp := e2eutils.MakeDeployParams(t, p)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	for _, garbageKind := range GarbageKinds {
 		sd := e2eutils.Setup(t, dp, defaultAlloc)
 		log := testlog.Logger(t, log.LvlError)
@@ -340,7 +374,7 @@ func TestGarbageBatch(gt *testing.T) {
 	}
 }
 
-func TestExtendedTimeWithoutL1Batches(gt *testing.T) {
+func ExtendedTimeWithoutL1Batches(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	p := &e2eutils.TestParams{
 		MaxSequencerDrift:   20, // larger than L1 block time we simulate in this test (12)
@@ -349,6 +383,7 @@ func TestExtendedTimeWithoutL1Batches(gt *testing.T) {
 		L1BlockTime:         12,
 	}
 	dp := e2eutils.MakeDeployParams(t, p)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlError)
 	miner, engine, sequencer := setupSequencerTest(t, sd, log)
@@ -386,7 +421,7 @@ func TestExtendedTimeWithoutL1Batches(gt *testing.T) {
 	require.Equal(t, sequencer.L2Unsafe(), sequencer.L2Safe(), "same for sequencer")
 }
 
-// TestBigL2Txs tests a high-throughput case with constrained batcher:
+// BigL2Txs tests a high-throughput case with constrained batcher:
 //   - Fill 40 L2 blocks to near max-capacity, with txs of 120 KB each
 //   - Buffer the L2 blocks into channels together as much as possible, submit data-txs only when necessary
 //     (just before crossing the max RLP channel size)
@@ -398,7 +433,7 @@ func TestExtendedTimeWithoutL1Batches(gt *testing.T) {
 // The goal of this test is to quickly run through an otherwise very slow process of submitting and including lots of data.
 // This does not test the batcher code, but is really focused at testing the batcher utils
 // and channel-decoding verifier code in the derive package.
-func TestBigL2Txs(gt *testing.T) {
+func BigL2Txs(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	p := &e2eutils.TestParams{
 		MaxSequencerDrift:   100,
@@ -407,6 +442,7 @@ func TestBigL2Txs(gt *testing.T) {
 		L1BlockTime:         12,
 	}
 	dp := e2eutils.MakeDeployParams(t, p)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlInfo)
 	miner, engine, sequencer := setupSequencerTest(t, sd, log)
@@ -464,7 +500,7 @@ func TestBigL2Txs(gt *testing.T) {
 				Value:     big.NewInt(0),
 				Data:      data,
 			})
-			require.NoError(gt, cl.SendTransaction(t.Ctx(), tx))
+			require.NoError(t, cl.SendTransaction(t.Ctx(), tx))
 			engine.ActL2IncludeTx(dp.Addresses.Alice)(t)
 		}
 		sequencer.ActL2EndBlock(t)

op-e2e/actions/l2_proposer_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
@@ -14,9 +15,34 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 )
 
-func TestProposer(gt *testing.T) {
+// TestProposerBatchType run each proposer-related test case in singular batch mode and span batch mode.
+func TestProposerBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"RunProposerTest", RunProposerTest},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
+func RunProposerTest(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, seqEngine, sequencer := setupSequencerTest(t, sd, log)

op-e2e/actions/reorg_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"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/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/log"
@@ -21,8 +22,9 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 )
 
-func setupReorgTest(t Testing, config *e2eutils.TestParams) (*e2eutils.SetupData, *e2eutils.DeployParams, *L1Miner, *L2Sequencer, *L2Engine, *L2Verifier, *L2Engine, *L2Batcher) {
+func setupReorgTest(t Testing, config *e2eutils.TestParams, spanBatchTimeOffset *hexutil.Uint64) (*e2eutils.SetupData, *e2eutils.DeployParams, *L1Miner, *L2Sequencer, *L2Engine, *L2Verifier, *L2Engine, *L2Batcher) {
 	dp := e2eutils.MakeDeployParams(t, config)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
@@ -44,9 +46,38 @@ func setupReorgTestActors(t Testing, dp *e2eutils.DeployParams, sd *e2eutils.Set
 	return sd, dp, miner, sequencer, seqEngine, verifier, verifEngine, batcher
 }
 
-func TestReorgOrphanBlock(gt *testing.T) {
+// TestReorgBatchType run each reorg-related test case in singular batch mode and span batch mode.
+func TestReorgBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"ReorgOrphanBlock", ReorgOrphanBlock},
+		{"ReorgFlipFlop", ReorgFlipFlop},
+		{"DeepReorg", DeepReorg},
+		{"RestartOpGeth", RestartOpGeth},
+		{"ConflictingL2Blocks", ConflictingL2Blocks},
+		{"SyncAfterReorg", SyncAfterReorg},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
+func ReorgOrphanBlock(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
-	sd, _, miner, sequencer, _, verifier, verifierEng, batcher := setupReorgTest(t, defaultRollupTestParams)
+	sd, _, miner, sequencer, _, verifier, verifierEng, batcher := setupReorgTest(t, defaultRollupTestParams, spanBatchTimeOffset)
 	verifEngClient := verifierEng.EngineClient(t, sd.RollupCfg)
 
 	sequencer.ActL2PipelineFull(t)
@@ -112,9 +143,9 @@ func TestReorgOrphanBlock(gt *testing.T) {
 	require.Equal(t, verifier.L2Safe(), sequencer.L2Safe(), "verifier and sequencer see same safe L2 block, while only verifier dealt with the orphan and replay")
 }
 
-func TestReorgFlipFlop(gt *testing.T) {
+func ReorgFlipFlop(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
-	sd, _, miner, sequencer, _, verifier, verifierEng, batcher := setupReorgTest(t, defaultRollupTestParams)
+	sd, _, miner, sequencer, _, verifier, verifierEng, batcher := setupReorgTest(t, defaultRollupTestParams, spanBatchTimeOffset)
 	minerCl := miner.L1Client(t, sd.RollupCfg)
 	verifEngClient := verifierEng.EngineClient(t, sd.RollupCfg)
 	checkVerifEngine := func() {
@@ -333,7 +364,7 @@ func TestReorgFlipFlop(gt *testing.T) {
 // Verifier
 // - Unsafe head is 62
 // - Safe head is 42
-func TestDeepReorg(gt *testing.T) {
+func DeepReorg(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 
 	// Create actor and verification engine client
@@ -342,7 +373,7 @@ func TestDeepReorg(gt *testing.T) {
 		SequencerWindowSize: 20,
 		ChannelTimeout:      120,
 		L1BlockTime:         4,
-	})
+	}, spanBatchTimeOffset)
 	minerCl := miner.L1Client(t, sd.RollupCfg)
 	l2Client := seqEngine.EthClient()
 	verifEngClient := verifierEng.EngineClient(t, sd.RollupCfg)
@@ -566,9 +597,9 @@ type rpcWrapper struct {
 	client.RPC
 }
 
-// TestRestartOpGeth tests that the sequencer can restart its execution engine without rollup-node restart,
+// RestartOpGeth tests that the sequencer can restart its execution engine without rollup-node restart,
 // including recovering the finalized/safe state of L2 chain without reorging.
-func TestRestartOpGeth(gt *testing.T) {
+func RestartOpGeth(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dbPath := path.Join(t.TempDir(), "testdb")
 	dbOption := func(_ *ethconfig.Config, nodeCfg *node.Config) error {
@@ -576,6 +607,7 @@ func TestRestartOpGeth(gt *testing.T) {
 		return nil
 	}
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	jwtPath := e2eutils.WriteDefaultJWT(t)
@@ -660,12 +692,13 @@ func TestRestartOpGeth(gt *testing.T) {
 	require.Equal(t, statusBeforeRestart.SafeL2, sequencer.L2Safe(), "expecting the safe block to catch up to what it was before shutdown after syncing from L1, and not be stuck at the finalized block")
 }
 
-// TestConflictingL2Blocks tests that a second copy of the sequencer stack cannot introduce an alternative
+// ConflictingL2Blocks tests that a second copy of the sequencer stack cannot introduce an alternative
 // L2 block (compared to something already secured by the first sequencer):
 // the alt block is not synced by the verifier, in unsafe and safe sync modes.
-func TestConflictingL2Blocks(gt *testing.T) {
+func ConflictingL2Blocks(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 
@@ -772,7 +805,7 @@ func TestConflictingL2Blocks(gt *testing.T) {
 	require.Equal(t, sequencer.L2Unsafe(), altSequencer.L2Unsafe(), "and gets back in harmony with original sequencer")
 }
 
-func TestSyncAfterReorg(gt *testing.T) {
+func SyncAfterReorg(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	testingParams := e2eutils.TestParams{
 		MaxSequencerDrift:   60,
@@ -780,7 +813,7 @@ func TestSyncAfterReorg(gt *testing.T) {
 		ChannelTimeout:      2,
 		L1BlockTime:         12,
 	}
-	sd, dp, miner, sequencer, seqEngine, verifier, _, batcher := setupReorgTest(t, &testingParams)
+	sd, dp, miner, sequencer, seqEngine, verifier, _, batcher := setupReorgTest(t, &testingParams, spanBatchTimeOffset)
 	l2Client := seqEngine.EthClient()
 	log := testlog.Logger(t, log.LvlDebug)
 	addresses := e2eutils.CollectAddresses(sd, dp)

op-e2e/actions/sync_test.go

@@ -23,9 +23,35 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestDerivationWithFlakyL1RPC(gt *testing.T) {
+// TestSyncBatchType run each sync test case in singular batch mode and span batch mode.
+func TestSyncBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"DerivationWithFlakyL1RPC", DerivationWithFlakyL1RPC},
+		{"FinalizeWhileSyncing", FinalizeWhileSyncing},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
+func DerivationWithFlakyL1RPC(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlError) // mute all the temporary derivation errors that we forcefully create
 	_, _, miner, sequencer, _, verifier, _, batcher := setupReorgTestActors(t, dp, sd, log)
@@ -62,9 +88,10 @@ func TestDerivationWithFlakyL1RPC(gt *testing.T) {
 	require.Equal(t, sequencer.L2Unsafe(), verifier.L2Safe(), "verifier is synced")
 }
 
-func TestFinalizeWhileSyncing(gt *testing.T) {
+func FinalizeWhileSyncing(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlError) // mute all the temporary derivation errors that we forcefully create
 	_, _, miner, sequencer, _, verifier, _, batcher := setupReorgTestActors(t, dp, sd, log)

op-e2e/actions/system_config_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"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"
 	"github.com/stretchr/testify/require"
@@ -19,13 +20,40 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 )
 
-// TestBatcherKeyRotation tests that batcher A can operate, then be replaced with batcher B, then ignore old batcher A,
+// TestSystemConfigBatchType run each system config-related test case in singular batch mode and span batch mode.
+func TestSystemConfigBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"BatcherKeyRotation", BatcherKeyRotation},
+		{"GPOParamsChange", GPOParamsChange},
+		{"GasLimitChange", GasLimitChange},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
+// BatcherKeyRotation tests that batcher A can operate, then be replaced with batcher B, then ignore old batcher A,
 // and that the change to batcher B is reverted properly upon reorg of L1.
-func TestBatcherKeyRotation(gt *testing.T) {
+func BatcherKeyRotation(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
 	dp.DeployConfig.L2BlockTime = 2
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, seqEngine, sequencer := setupSequencerTest(t, sd, log)
@@ -198,11 +226,12 @@ func TestBatcherKeyRotation(gt *testing.T) {
 	require.Equal(t, sequencer.L2Unsafe(), verifier.L2Unsafe(), "verifier synced")
 }
 
-// TestGPOParamsChange tests that the GPO params can be updated to adjust fees of L2 transactions,
+// GPOParamsChange tests that the GPO params can be updated to adjust fees of L2 transactions,
 // and that the L1 data fees to the L2 transaction are applied correctly before, during and after the GPO update in L2.
-func TestGPOParamsChange(gt *testing.T) {
+func GPOParamsChange(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, seqEngine, sequencer := setupSequencerTest(t, sd, log)
@@ -326,12 +355,13 @@ func TestGPOParamsChange(gt *testing.T) {
 	require.Equal(t, "2.3", receipt.FeeScalar.String(), "2_300_000 divided by 6 decimals = float(2.3)")
 }
 
-// TestGasLimitChange tests that the gas limit can be configured to L1,
+// GasLimitChange tests that the gas limit can be configured to L1,
 // and that the L2 changes the gas limit instantly at the exact block that adopts the L1 origin with
 // the gas limit change event. And checks if a verifier node can reproduce the same gas limit change.
-func TestGasLimitChange(gt *testing.T) {
+func GasLimitChange(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 	miner, seqEngine, sequencer := setupSequencerTest(t, sd, log)

op-e2e/actions/user_test.go

@@ -13,10 +13,12 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 )
 
-type regolithScheduledTest struct {
-	name             string
-	regolithTime     *hexutil.Uint64
-	activateRegolith bool
+type hardforkScheduledTest struct {
+	name              string
+	regolithTime      *hexutil.Uint64
+	spanBatchTime     *hexutil.Uint64
+	activateRegolith  bool
+	activateSpanBatch bool
 }
 
 // TestCrossLayerUser tests that common actions of the CrossLayerUser actor work in various regolith configurations:
@@ -31,11 +33,18 @@ func TestCrossLayerUser(t *testing.T) {
 	zeroTime := hexutil.Uint64(0)
 	futureTime := hexutil.Uint64(20)
 	farFutureTime := hexutil.Uint64(2000)
-	tests := []regolithScheduledTest{
-		{name: "NoRegolith", regolithTime: nil, activateRegolith: false},
-		{name: "NotYetRegolith", regolithTime: &farFutureTime, activateRegolith: false},
-		{name: "RegolithAtGenesis", regolithTime: &zeroTime, activateRegolith: true},
-		{name: "RegolithAfterGenesis", regolithTime: &futureTime, activateRegolith: true},
+	tests := []hardforkScheduledTest{
+		{name: "NoRegolith", regolithTime: nil, activateRegolith: false, spanBatchTime: nil, activateSpanBatch: false},
+		{name: "NotYetRegolith", regolithTime: &farFutureTime, activateRegolith: false, spanBatchTime: nil, activateSpanBatch: false},
+		{name: "RegolithAtGenesis", regolithTime: &zeroTime, activateRegolith: true, spanBatchTime: nil, activateSpanBatch: false},
+		{name: "RegolithAfterGenesis", regolithTime: &futureTime, activateRegolith: true, spanBatchTime: nil, activateSpanBatch: false},
+		{name: "NoSpanBatch", regolithTime: &zeroTime, activateRegolith: true, spanBatchTime: nil, activateSpanBatch: false},
+		{name: "NotYetSpanBatch", regolithTime: &zeroTime, activateRegolith: true,
+			spanBatchTime: &farFutureTime, activateSpanBatch: false},
+		{name: "SpanBatchAtGenesis", regolithTime: &zeroTime, activateRegolith: true,
+			spanBatchTime: &zeroTime, activateSpanBatch: true},
+		{name: "SpanBatchAfterGenesis", regolithTime: &zeroTime, activateRegolith: true,
+			spanBatchTime: &futureTime, activateSpanBatch: true},
 	}
 	for _, test := range tests {
 		test := test // Use a fixed reference as the tests run in parallel
@@ -45,10 +54,11 @@ func TestCrossLayerUser(t *testing.T) {
 	}
 }
 
-func runCrossLayerUserTest(gt *testing.T, test regolithScheduledTest) {
+func runCrossLayerUserTest(gt *testing.T, test hardforkScheduledTest) {
 	t := NewDefaultTesting(gt)
 	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
 	dp.DeployConfig.L2GenesisRegolithTimeOffset = test.regolithTime
+	dp.DeployConfig.L2GenesisSpanBatchTimeOffset = test.spanBatchTime
 	sd := e2eutils.Setup(t, dp, defaultAlloc)
 	log := testlog.Logger(t, log.LvlDebug)
 

op-e2e/e2eutils/setup.go

@@ -59,7 +59,6 @@ func MakeDeployParams(t require.TestingT, tp *TestParams) *DeployParams {
 	deployConfig.L1BlockTime = tp.L1BlockTime
 	deployConfig.L2GenesisRegolithTimeOffset = nil
 	deployConfig.L2GenesisCanyonTimeOffset = CanyonTimeOffset()
-	deployConfig.L2GenesisSpanBatchTimeOffset = SpanBatchTimeOffset()
 
 	require.NoError(t, deployConfig.Check())
 	require.Equal(t, addresses.Batcher, deployConfig.BatchSenderAddress)
@@ -186,14 +185,6 @@ func SystemConfigFromDeployConfig(deployConfig *genesis.DeployConfig) eth.System
 	}
 }
 
-func SpanBatchTimeOffset() *hexutil.Uint64 {
-	if os.Getenv("OP_E2E_USE_SPAN_BATCH") == "true" {
-		offset := hexutil.Uint64(0)
-		return &offset
-	}
-	return nil
-}
-
 func CanyonTimeOffset() *hexutil.Uint64 {
 	if os.Getenv("OP_E2E_USE_CANYON") == "true" {
 		offset := hexutil.Uint64(0)

op-e2e/setup.go

@@ -88,7 +88,6 @@ func DefaultSystemConfig(t *testing.T) SystemConfig {
 	deployConfig := config.DeployConfig.Copy()
 	deployConfig.L1GenesisBlockTimestamp = hexutil.Uint64(time.Now().Unix())
 	deployConfig.L2GenesisCanyonTimeOffset = e2eutils.CanyonTimeOffset()
-	deployConfig.L2GenesisSpanBatchTimeOffset = e2eutils.SpanBatchTimeOffset()
 	require.NoError(t, deployConfig.Check(), "Deploy config is invalid, do you need to run make devnet-allocs?")
 	l1Deployments := config.L1Deployments.Copy()
 	require.NoError(t, l1Deployments.Check())
@@ -684,7 +683,7 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 	}
 
 	var batchType uint = derive.SingularBatchType
-	if os.Getenv("OP_E2E_USE_SPAN_BATCH") == "true" {
+	if cfg.DeployConfig.L2GenesisSpanBatchTimeOffset != nil && *cfg.DeployConfig.L2GenesisSpanBatchTimeOffset == hexutil.Uint64(0) {
 		batchType = derive.SpanBatchType
 	}
 	batcherMaxL1TxSizeBytes := cfg.BatcherMaxL1TxSizeBytes

op-e2e/system_fpp_test.go

@@ -15,25 +15,42 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stretchr/testify/require"
 )
 
 func TestVerifyL2OutputRoot(t *testing.T) {
-	testVerifyL2OutputRoot(t, false)
+	testVerifyL2OutputRoot(t, false, false)
+}
+
+func TestVerifyL2OutputRootSpanBatch(t *testing.T) {
+	testVerifyL2OutputRoot(t, false, true)
 }
 
 func TestVerifyL2OutputRootDetached(t *testing.T) {
-	testVerifyL2OutputRoot(t, true)
+	testVerifyL2OutputRoot(t, true, false)
+}
+
+func TestVerifyL2OutputRootDetachedSpanBatch(t *testing.T) {
+	testVerifyL2OutputRoot(t, true, true)
 }
 
 func TestVerifyL2OutputRootEmptyBlock(t *testing.T) {
-	testVerifyL2OutputRootEmptyBlock(t, false)
+	testVerifyL2OutputRootEmptyBlock(t, false, false)
+}
+
+func TestVerifyL2OutputRootEmptyBlockSpanBatch(t *testing.T) {
+	testVerifyL2OutputRootEmptyBlock(t, false, true)
 }
 
 func TestVerifyL2OutputRootEmptyBlockDetached(t *testing.T) {
-	testVerifyL2OutputRootEmptyBlock(t, true)
+	testVerifyL2OutputRootEmptyBlock(t, true, false)
+}
+
+func TestVerifyL2OutputRootEmptyBlockDetachedSpanBatch(t *testing.T) {
+	testVerifyL2OutputRootEmptyBlock(t, true, true)
 }
 
 // TestVerifyL2OutputRootEmptyBlock asserts that the program can verify the output root of an empty block
@@ -46,7 +63,7 @@ func TestVerifyL2OutputRootEmptyBlockDetached(t *testing.T) {
 // - reboot the batch submitter
 // - update the state root via a tx
 // - run program
-func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
+func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool, spanBatchActivated bool) {
 	InitParallel(t)
 	ctx := context.Background()
 
@@ -56,6 +73,13 @@ func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
 	// Use a small sequencer window size to avoid test timeout while waiting for empty blocks
 	// But not too small to ensure that our claim and subsequent state change is published
 	cfg.DeployConfig.SequencerWindowSize = 16
+	if spanBatchActivated {
+		// Activate span batch hard fork
+		minTs := hexutil.Uint64(0)
+		cfg.DeployConfig.L2GenesisSpanBatchTimeOffset = &minTs
+	} else {
+		cfg.DeployConfig.L2GenesisSpanBatchTimeOffset = nil
+	}
 
 	sys, err := cfg.Start(t)
 	require.Nil(t, err, "Error starting up system")
@@ -147,13 +171,20 @@ func testVerifyL2OutputRootEmptyBlock(t *testing.T, detached bool) {
 	})
 }
 
-func testVerifyL2OutputRoot(t *testing.T, detached bool) {
+func testVerifyL2OutputRoot(t *testing.T, detached bool, spanBatchActivated bool) {
 	InitParallel(t)
 	ctx := context.Background()
 
 	cfg := DefaultSystemConfig(t)
 	// We don't need a verifier - just the sequencer is enough
 	delete(cfg.Nodes, "verifier")
+	if spanBatchActivated {
+		// Activate span batch hard fork
+		minTs := hexutil.Uint64(0)
+		cfg.DeployConfig.L2GenesisSpanBatchTimeOffset = &minTs
+	} else {
+		cfg.DeployConfig.L2GenesisSpanBatchTimeOffset = nil
+	}
 
 	sys, err := cfg.Start(t)
 	require.Nil(t, err, "Error starting up system")

op-e2e/system_test.go

@@ -45,6 +45,31 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/testlog"
 )
 
+// TestSystemBatchType run each system e2e test case in singular batch mode and span batch mode.
+// If the test case tests batch submission and advancing safe head, it should be tested in both singular and span batch mode.
+func TestSystemBatchType(t *testing.T) {
+	tests := []struct {
+		name string
+		f    func(gt *testing.T, spanBatchTimeOffset *hexutil.Uint64)
+	}{
+		{"StopStartBatcher", StopStartBatcher},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SingularBatch", func(t *testing.T) {
+			test.f(t, nil)
+		})
+	}
+
+	spanBatchTimeOffset := hexutil.Uint64(0)
+	for _, test := range tests {
+		test := test
+		t.Run(test.name+"_SpanBatch", func(t *testing.T) {
+			test.f(t, &spanBatchTimeOffset)
+		})
+	}
+}
+
 func TestMain(m *testing.M) {
 	if config.ExternalL2Shim != "" {
 		fmt.Println("Running tests with external L2 process adapter at ", config.ExternalL2Shim)
@@ -1222,10 +1247,11 @@ func TestFees(t *testing.T) {
 	require.Equal(t, balanceDiff, totalFee, "balances should add up")
 }
 
-func TestStopStartBatcher(t *testing.T) {
+func StopStartBatcher(t *testing.T, spanBatchTimeOffset *hexutil.Uint64) {
 	InitParallel(t)
 
 	cfg := DefaultSystemConfig(t)
+	cfg.DeployConfig.L2GenesisSpanBatchTimeOffset = spanBatchTimeOffset
 	sys, err := cfg.Start(t)
 	require.Nil(t, err, "Error starting up system")
 	defer sys.Close()

op-node/p2p/gossip.go

@@ -326,6 +326,12 @@ func BuildBlocksValidator(log log.Logger, cfg *rollup.Config, runCfg GossipRunti
 			return pubsub.ValidationReject
 		}
 
+		// [REJECT] if a V2 Block has non-empty withdrawals
+		if blockVersion == eth.BlockV2 && len(*payload.Withdrawals) != 0 {
+			log.Warn("payload is on v2 topic, but has non-empty withdrawals", "bad_hash", payload.BlockHash.String(), "withdrawal_count", len(*payload.Withdrawals))
+			return pubsub.ValidationReject
+		}
+
 		seen, ok := blockHeightLRU.Get(uint64(payload.BlockNumber))
 		if !ok {
 			seen = new(seenBlocks)

op-node/p2p/gossip_test.go

 package p2p
 
 import (
+	"bytes"
 	"context"
+	"fmt"
 	"math/big"
 	"testing"
+	"time"
 
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/golang/snappy"
+
+	// "github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum-optimism/optimism/op-service/testutils"
 	"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/crypto"
 
 	"github.com/ethereum/go-ethereum/log"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	pubsub_pb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/stretchr/testify/require"
 
@@ -89,3 +99,65 @@ func TestVerifyBlockSignature(t *testing.T) {
 		require.Equal(t, pubsub.ValidationIgnore, result)
 	})
 }
+
+func createSignedP2Payload(payload *eth.ExecutionPayload, signer Signer, l2ChainID *big.Int) ([]byte, error) {
+	var buf bytes.Buffer
+	buf.Write(make([]byte, 65))
+	if _, err := payload.MarshalSSZ(&buf); err != nil {
+		return nil, fmt.Errorf("failed to encoded execution payload to publish: %w", err)
+	}
+	data := buf.Bytes()
+	payloadData := data[65:]
+	sig, err := signer.Sign(context.TODO(), SigningDomainBlocksV1, l2ChainID, payloadData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign execution payload with signer: %w", err)
+	}
+	copy(data[:65], sig[:])
+
+	// compress the full message
+	// This also copies the data, freeing up the original buffer to go back into the pool
+	return snappy.Encode(nil, data), nil
+}
+
+// TestBlockValidator does some very basic tests of the p2p block validation logic
+func TestBlockValidator(t *testing.T) {
+	// Params Set 1: Create the validation function
+	cfg := &rollup.Config{
+		L2ChainID: big.NewInt(100),
+	}
+	secrets, err := e2eutils.DefaultMnemonicConfig.Secrets()
+	require.NoError(t, err)
+	runCfg := &testutils.MockRuntimeConfig{P2PSeqAddress: crypto.PubkeyToAddress(secrets.SequencerP2P.PublicKey)}
+	signer := &PreparedSigner{Signer: NewLocalSigner(secrets.SequencerP2P)}
+
+	// valFnV1 := BuildBlocksValidator(testlog.Logger(t, log.LvlCrit), rollupCfg, runCfg, eth.BlockV1)
+	valFnV2 := BuildBlocksValidator(testlog.Logger(t, log.LvlCrit), cfg, runCfg, eth.BlockV2)
+
+	// Params Set 2: Call the validation function
+	peerID := peer.ID("foo")
+
+	// Valid Case
+	payload := eth.ExecutionPayload{
+		Timestamp:   hexutil.Uint64(time.Now().Unix()),
+		Withdrawals: &types.Withdrawals{},
+	}
+	payload.BlockHash, _ = payload.CheckBlockHash() // hack to generate the block hash easily.
+	data, err := createSignedP2Payload(&payload, signer, cfg.L2ChainID)
+	require.NoError(t, err)
+	message := &pubsub.Message{Message: &pubsub_pb.Message{Data: data}}
+	res := valFnV2(context.TODO(), peerID, message)
+	require.Equal(t, res, pubsub.ValidationAccept)
+
+	// Invalid because non-empty withdrawals when Canyon is active
+	payload = eth.ExecutionPayload{
+		Timestamp:   hexutil.Uint64(time.Now().Unix()),
+		Withdrawals: &types.Withdrawals{&types.Withdrawal{Index: 1, Validator: 1}},
+	}
+	payload.BlockHash, _ = payload.CheckBlockHash()
+	data, err = createSignedP2Payload(&payload, signer, cfg.L2ChainID)
+	require.NoError(t, err)
+	message = &pubsub.Message{Message: &pubsub_pb.Message{Data: data}}
+	res = valFnV2(context.TODO(), peerID, message)
+	require.Equal(t, res, pubsub.ValidationReject)
+
+}

op-node/rollup/superchain.go

@@ -110,5 +110,9 @@ func LoadOPStackRollupConfig(chainID uint64) (*Config, error) {
 		cfg.ChannelTimeout = 120
 		cfg.MaxSequencerDrift = 1200
 	}
+	if chainID == pgnSepolia {
+		cfg.MaxSequencerDrift = 1000
+		cfg.SeqWindowSize = 7200
+	}
 	return cfg, nil
 }

op-service/eth/block_info.go

@@ -20,6 +20,7 @@ type BlockInfo interface {
 	BaseFee() *big.Int
 	ReceiptHash() common.Hash
 	GasUsed() uint64
+	GasLimit() uint64
 
 	// HeaderRLP returns the RLP of the block header as per consensus rules
 	// Returns an error if the header RLP could not be written
@@ -100,6 +101,10 @@ func (h headerBlockInfo) GasUsed() uint64 {
 	return h.Header.GasUsed
 }
 
+func (h headerBlockInfo) GasLimit() uint64 {
+	return h.Header.GasLimit
+}
+
 func (h headerBlockInfo) HeaderRLP() ([]byte, error) {
 	return rlp.EncodeToBytes(h.Header)
 }

op-service/sources/types.go

@@ -78,6 +78,10 @@ func (h headerInfo) GasUsed() uint64 {
 	return h.Header.GasUsed
 }
 
+func (h headerInfo) GasLimit() uint64 {
+	return h.Header.GasLimit
+}
+
 func (h headerInfo) HeaderRLP() ([]byte, error) {
 	return rlp.EncodeToBytes(h.Header)
 }

op-service/testutils/l1info.go

@@ -23,6 +23,7 @@ type MockBlockInfo struct {
 	InfoBaseFee     *big.Int
 	InfoReceiptRoot common.Hash
 	InfoGasUsed     uint64
+	InfoGasLimit    uint64
 	InfoHeaderRLP   []byte
 }
 
@@ -66,6 +67,10 @@ func (l *MockBlockInfo) GasUsed() uint64 {
 	return l.InfoGasUsed
 }
 
+func (l *MockBlockInfo) GasLimit() uint64 {
+	return l.InfoGasLimit
+}
+
 func (l *MockBlockInfo) ID() eth.BlockID {
 	return eth.BlockID{Hash: l.InfoHash, Number: l.InfoNum}
 }

package.json

@@ -49,7 +49,7 @@
     "chai": "^4.3.10",
     "depcheck": "^1.4.7",
     "doctoc": "^2.2.0",
-    "eslint": "^8.52.0",
+    "eslint": "^8.53.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-config-standard": "^16.0.3",
     "eslint-plugin-import": "^2.29.0",
@@ -65,7 +65,7 @@
     "markdownlint": "^0.31.0",
     "markdownlint-cli2": "0.4.0",
     "mocha": "^10.2.0",
-    "nx": "17.0.2",
+    "nx": "17.0.3",
     "nyc": "^15.1.0",
     "patch-package": "^8.0.0",
     "prettier": "^2.8.0",

packages/contracts-bedrock/.gas-snapshot

@@ -140,7 +140,7 @@ GasBenchMark_L1StandardBridge_Finalize:test_finalizeETHWithdrawal_benchmark() (g
 GasBenchMark_L2OutputOracle:test_proposeL2Output_benchmark() (gas: 88797)
 GasBenchMark_OptimismPortal:test_depositTransaction_benchmark() (gas: 68320)
 GasBenchMark_OptimismPortal:test_depositTransaction_benchmark_1() (gas: 68973)
-GasBenchMark_OptimismPortal:test_proveWithdrawalTransaction_benchmark() (gas: 143295)
+GasBenchMark_OptimismPortal:test_proveWithdrawalTransaction_benchmark() (gas: 143303)
 GasPriceOracle_Test:test_baseFee_succeeds() (gas: 8348)
 GasPriceOracle_Test:test_decimals_succeeds() (gas: 6234)
 GasPriceOracle_Test:test_gasPrice_succeeds() (gas: 8340)

packages/contracts-bedrock/periphery-deploy-config/4460.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/58008.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/84532.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/901.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/919.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/999999999.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/optimism-goerli.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0x636Af16bf2f682dD3109e60102b8E1A089FedAa8",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/optimism-sepolia.json

@@ -20,5 +20,22 @@
   "faucetOnchainAuthModuleAmount": 1000000000000000000,
   "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
   "faucetOffchainAuthModuleTtl": 86400,
-  "faucetOffchainAuthModuleAmount": 50000000000000000
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": false,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 1,
+  "previousDripVersion": 0,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
 }

packages/contracts-bedrock/periphery-deploy-config/sepolia.json

+{
+  "faucetAdmin": "0x212E789D4523D4BAF464f8Fb2A9B9dff2B36e5A6",
+  "faucetDrippieOwner": "0x10ab157483dd308f8B38aCF2ad823dfD255F56b5",
+  "faucetDripV1Value": 20000000000000000000,
+  "faucetDripV1Interval": 3600,
+  "faucetDripV1Threshold": 100000000000000000000,
+  "faucetDripV2Interval": 604800,
+  "faucetDripV2Threshold": 20000000000000000000,
+  "faucetDripV2Value": 500000000000000000000,
+  "faucetAdminDripV1Interval": 86400,
+  "faucetAdminDripV1Threshold": 100000000000000000,
+  "faucetAdminDripV1Value": 1000000000000000000,
+  "faucetGelatoTreasury": "0x644CB00854EDC55FE8CCC9c1967BABb22F08Ad2f",
+  "faucetGelatoRecipient": "0x0E9b4649eB0760A4F01646636E032D68cFDe58FF",
+  "faucetGelatoBalanceV1DripInterval": 86400,
+  "faucetGelatoBalanceV1Value": 1000000000000000000,
+  "faucetGelatoThreshold": 100000000000000000,
+  "faucetOnchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
+  "faucetOnchainAuthModuleTtl": 86400,
+  "faucetOnchainAuthModuleAmount": 1000000000000000000,
+  "faucetOffchainAuthModuleAdmin": "0xFe44Ae787A632c45ACea658492dDBebE39f002aC",
+  "faucetOffchainAuthModuleTtl": 86400,
+  "faucetOffchainAuthModuleAmount": 50000000000000000,
+  "opL1BridgeAddress": "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1",
+  "baseL1BridgeAddress": "0xfd0Bf71F60660E2f608ed56e1659C450eB113120",
+  "pgnL1BridgeAddress": "0xFaE6abCAF30D23e233AC7faF747F2fC3a5a6Bfa3",
+  "zoraL1BridgeAddress": "0x5376f1D543dcbB5BD416c56C189e4cB7399fCcCB",
+  "orderlyL1BridgeAddress": "0x1Af0494040d6904A9F3EE21921de4b359C736333",
+  "modeL1BridgeAddress": "0xbC5C679879B2965296756CD959C3C739769995E2",
+  "lyraL1BridgeAddress": "0x915f179A77FB2e1AeA8b56Ebc0D75A7e1A8a7A17",
+  "installOpChainFaucetsDrips": true,
+  "archivePreviousOpChainFaucetsDrips": false,
+  "dripVersion": 2,
+  "previousDripVersion": 1,
+  "smallOpChainFaucetDripValue": 2000000000000000000,
+  "smallOpChainFaucetDripInterval": 86400,
+  "largeOpChainFaucetDripValue": 34000000000000000000,
+  "largeOpChainFaucetDripInterval": 86400,
+  "opChainAdminWalletDripValue": 1000000000000000000,
+  "opChainAdminWalletDripInterval": 2592000
+}

packages/contracts-bedrock/scripts/Deployer.sol

@@ -88,7 +88,10 @@ abstract contract Deployer is Script {
         string memory chainIdPath = string.concat(deploymentsDir, "/.chainId");
         try vm.readFile(chainIdPath) returns (string memory localChainId) {
             if (vm.envOr("STRICT_DEPLOYMENT", true)) {
-                require(vm.parseUint(localChainId) == chainId, "Misconfigured networks");
+                require(
+                    vm.parseUint(localChainId) == chainId,
+                    string.concat("Misconfigured networks: ", localChainId, " != ", vm.toString(chainId))
+                );
             }
         } catch {
             vm.writeFile(chainIdPath, vm.toString(chainId));

packages/contracts-bedrock/scripts/PeripheryDeployConfig.s.sol

@@ -34,6 +34,25 @@ contract PeripheryDeployConfig is Script {
     address public faucetOffchainAuthModuleAdmin;
     uint256 public faucetOffchainAuthModuleTtl;
     uint256 public faucetOffchainAuthModuleAmount;
+    bool public installOpChainFaucetsDrips;
+    bool public archivePreviousOpChainFaucetsDrips;
+    uint256 public smallOpChainFaucetDripValue;
+    uint256 public smallOpChainFaucetDripInterval;
+    uint256 public largeOpChainFaucetDripValue;
+    uint256 public largeOpChainFaucetDripInterval;
+    uint256 public opChainAdminWalletDripValue;
+    uint256 public opChainAdminWalletDripInterval;
+    address public opL1BridgeAddress;
+    address public baseL1BridgeAddress;
+    address public zoraL1BridgeAddress;
+    address public pgnL1BridgeAddress;
+    address public orderlyL1BridgeAddress;
+    address public modeL1BridgeAddress;
+    address public lyraL1BridgeAddress;
+    address[5] public smallFaucetsL1BridgeAddresses;
+    address[2] public largeFaucetsL1BridgeAddresses;
+    uint256 public dripVersion;
+    uint256 public previousDripVersion;
 
     constructor(string memory _path) {
         console.log("PeripheryDeployConfig: reading file %s", _path);
@@ -66,5 +85,37 @@ contract PeripheryDeployConfig is Script {
         faucetOffchainAuthModuleAdmin = stdJson.readAddress(_json, "$.faucetOffchainAuthModuleAdmin");
         faucetOffchainAuthModuleTtl = stdJson.readUint(_json, "$.faucetOffchainAuthModuleTtl");
         faucetOffchainAuthModuleAmount = stdJson.readUint(_json, "$.faucetOffchainAuthModuleAmount");
+        installOpChainFaucetsDrips = stdJson.readBool(_json, "$.installOpChainFaucetsDrips");
+        archivePreviousOpChainFaucetsDrips = stdJson.readBool(_json, "$.archivePreviousOpChainFaucetsDrips");
+        opL1BridgeAddress = stdJson.readAddress(_json, "$.opL1BridgeAddress");
+        baseL1BridgeAddress = stdJson.readAddress(_json, "$.baseL1BridgeAddress");
+        zoraL1BridgeAddress = stdJson.readAddress(_json, "$.zoraL1BridgeAddress");
+        pgnL1BridgeAddress = stdJson.readAddress(_json, "$.pgnL1BridgeAddress");
+        orderlyL1BridgeAddress = stdJson.readAddress(_json, "$.orderlyL1BridgeAddress");
+        modeL1BridgeAddress = stdJson.readAddress(_json, "$.modeL1BridgeAddress");
+        lyraL1BridgeAddress = stdJson.readAddress(_json, "$.lyraL1BridgeAddress");
+        dripVersion = stdJson.readUint(_json, "$.dripVersion");
+        previousDripVersion = stdJson.readUint(_json, "$.previousDripVersion");
+        smallOpChainFaucetDripValue = stdJson.readUint(_json, "$.smallOpChainFaucetDripValue");
+        smallOpChainFaucetDripInterval = stdJson.readUint(_json, "$.smallOpChainFaucetDripInterval");
+        largeOpChainFaucetDripValue = stdJson.readUint(_json, "$.largeOpChainFaucetDripValue");
+        largeOpChainFaucetDripInterval = stdJson.readUint(_json, "$.largeOpChainFaucetDripInterval");
+        opChainAdminWalletDripValue = stdJson.readUint(_json, "$.opChainAdminWalletDripValue");
+        opChainAdminWalletDripInterval = stdJson.readUint(_json, "$.opChainAdminWalletDripInterval");
+        largeFaucetsL1BridgeAddresses[0] = opL1BridgeAddress;
+        largeFaucetsL1BridgeAddresses[1] = baseL1BridgeAddress;
+        smallFaucetsL1BridgeAddresses[0] = zoraL1BridgeAddress;
+        smallFaucetsL1BridgeAddresses[1] = pgnL1BridgeAddress;
+        smallFaucetsL1BridgeAddresses[2] = orderlyL1BridgeAddress;
+        smallFaucetsL1BridgeAddresses[3] = modeL1BridgeAddress;
+        smallFaucetsL1BridgeAddresses[4] = lyraL1BridgeAddress;
+    }
+
+    function getSmallFaucetsL1BridgeAddressesCount() public view returns (uint256 count) {
+        return smallFaucetsL1BridgeAddresses.length;
+    }
+
+    function getLargeFaucetsL1BridgeAddressesCount() public view returns (uint256 count) {
+        return largeFaucetsL1BridgeAddresses.length;
     }
 }

packages/contracts-ts/package.json

@@ -82,6 +82,6 @@
     "change-case": "4.1.2",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "viem": "^1.18.4"
+    "viem": "^1.18.6"
   }
 }

packages/fee-estimation/package.json

@@ -44,7 +44,7 @@
     "jsdom": "^22.1.0",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
-    "viem": "^1.18.4",
+    "viem": "^1.18.6",
     "vite": "^4.5.0",
     "vitest": "^0.34.2"
   },

packages/sdk/package.json

@@ -56,7 +56,7 @@
     "ts-node": "^10.9.1",
     "typedoc": "^0.25.3",
     "typescript": "^5.2.2",
-    "viem": "^1.18.4",
+    "viem": "^1.18.6",
     "vitest": "^0.34.2",
     "zod": "^3.22.4"
   },

packages/web3js-plugin/package.json

@@ -37,7 +37,7 @@
     "@vitest/coverage-istanbul": "^0.34.6",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
-    "viem": "^1.18.4",
+    "viem": "^1.18.6",
     "vite": "^4.5.0",
     "vitest": "^0.34.1",
     "zod": "^3.22.4"

specs/derivation.md

@@ -694,9 +694,12 @@ equivalents. The `v2` methods are backwards compatible with `v1` payloads but su
 [`engine_getPayloadV2`]: exec-engine.md#engine_getpayloadv2
 [`engine_newPayloadV2`]: exec-engine.md#engine_newpayloadv2
 
-The execution payload is an object of type [`ExecutionPayloadV1`][eth-payload].
+The execution payload is an object of type [`ExecutionPayloadV2`][eth-payload].
 
-[eth-payload]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#executionpayloadv1
+[eth-payload]: https://github.com/ethereum/execution-apis/blob/main/src/engine/shanghai.md#payloadattributesv2
+
+With V2 of the execution payload, before Canyon the withdrawals field is required to be nil. After Canyon the
+withdrawals field is required to be non-nil. The op-node should set the withdrawals field to be an empty list.
 
 #### Forkchoice synchronization
 

specs/rollup-node-p2p.md

@@ -291,6 +291,7 @@ An [extended-validator] checks the incoming messages as follows, in order of ope
 - `[REJECT]` if the `block_hash` in the `payload` is not valid
 - `[REJECT]` if the block is on the V1 topic and has withdrawals
 - `[REJECT]` if the block is on the V2 topic and does not have withdrawals
+- `[REJECT]` if the block is on the V2 topic and has a non-zero amount of withdrawals
 - `[REJECT]` if more than 5 different blocks have been seen with the same block height
 - `[IGNORE]` if the block has already been seen
 - `[REJECT]` if the signature by the sequencer is not valid