Move compressor and CLI configuration to separate package

op-batcher/batcher/channel_builder.go

@@ -7,7 +7,7 @@ import (
 	"io"
 	"math"
 
-	"github.com/ethereum-optimism/optimism/op-batcher/flags"
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum/go-ethereum/core/types"
 )
@@ -55,21 +55,11 @@ type ChannelConfig struct {
 	SubSafetyMargin uint64
 	// The maximum byte-size a frame can have.
 	MaxFrameSize uint64
-	// The target number of frames to create per channel. Note that if the
-	// realized compression ratio is worse than the approximate, more frames may
-	// actually be created. This also depends on how close TargetFrameSize is to
-	// MaxFrameSize.
-	TargetFrameSize uint64
-	// The target number of frames to create in this channel. If the realized
-	// compression ratio is worse than approxComprRatio, additional leftover
-	// frame(s) might get created.
-	TargetNumFrames int
-	// Approximated compression ratio to assume. Should be slightly smaller than
-	// average from experiments to avoid the chances of creating a small
-	// additional leftover frame.
-	ApproxComprRatio float64
-	// CompressorKind is the compressor implementation to use.
-	CompressorKind flags.CompressorKind
+
+	// CompressorConfig contains the configuration for creating new compressors.
+	CompressorConfig compressor.Config
+	// CompressorFactory creates new compressors.
+	CompressorFactory compressor.FactoryFunc
 }
 
 // Check validates the [ChannelConfig] parameters.
@@ -98,22 +88,6 @@ func (cc *ChannelConfig) Check() error {
 	return nil
 }
 
-func (cc *ChannelConfig) NewCompressor() (derive.Compressor, error) {
-	switch cc.CompressorKind {
-	case flags.ShadowCompressorKind:
-		return NewShadowCompressor(
-			cc.TargetFrameSize,
-			cc.TargetNumFrames,
-		)
-	default:
-		return NewRatioCompressor(
-			cc.TargetFrameSize,
-			cc.TargetNumFrames,
-			cc.ApproxComprRatio,
-		)
-	}
-}
-
 type frameID struct {
 	chID        derive.ChannelID
 	frameNumber uint16
@@ -154,7 +128,7 @@ type channelBuilder struct {
 // newChannelBuilder creates a new channel builder or returns an error if the
 // channel out could not be created.
 func newChannelBuilder(cfg ChannelConfig) (*channelBuilder, error) {
-	c, err := cfg.NewCompressor()
+	c, err := cfg.CompressorFactory(cfg.CompressorConfig)
 	if err != nil {
 		return nil, err
 	}

op-batcher/batcher/channel_builder_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"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"
@@ -28,9 +29,12 @@ var defaultTestChannelConfig = ChannelConfig{
 	MaxChannelDuration: 1,
 	SubSafetyMargin:    4,
 	MaxFrameSize:       120000,
+	CompressorConfig: compressor.Config{
 		TargetFrameSize:  100000,
 		TargetNumFrames:  1,
 		ApproxComprRatio: 0.4,
+	},
+	CompressorFactory: compressor.NewRatioCompressor,
 }
 
 // TestChannelConfig_Check tests the [ChannelConfig] [Check] function.
@@ -416,7 +420,7 @@ func TestChannelBuilder_OutputWrongFramePanic(t *testing.T) {
 
 	// Mock the internals of `channelBuilder.outputFrame`
 	// to construct a single frame
-	c, err := channelConfig.NewCompressor()
+	c, err := channelConfig.CompressorFactory(channelConfig.CompressorConfig)
 	require.NoError(t, err)
 	co, err := derive.NewChannelOut(c)
 	require.NoError(t, err)
@@ -485,8 +489,8 @@ func TestChannelBuilder_MaxRLPBytesPerChannel(t *testing.T) {
 	t.Parallel()
 	channelConfig := defaultTestChannelConfig
 	channelConfig.MaxFrameSize = derive.MaxRLPBytesPerChannel * 2
-	channelConfig.TargetFrameSize = derive.MaxRLPBytesPerChannel * 2
-	channelConfig.ApproxComprRatio = 1
+	channelConfig.CompressorConfig.TargetFrameSize = derive.MaxRLPBytesPerChannel * 2
+	channelConfig.CompressorConfig.ApproxComprRatio = 1
 
 	// Construct the channel builder
 	cb, err := newChannelBuilder(channelConfig)
@@ -502,9 +506,9 @@ func TestChannelBuilder_MaxRLPBytesPerChannel(t *testing.T) {
 func TestChannelBuilder_OutputFramesMaxFrameIndex(t *testing.T) {
 	channelConfig := defaultTestChannelConfig
 	channelConfig.MaxFrameSize = 24
-	channelConfig.TargetNumFrames = math.MaxInt
-	channelConfig.TargetFrameSize = 24
-	channelConfig.ApproxComprRatio = 0
+	channelConfig.CompressorConfig.TargetNumFrames = math.MaxInt
+	channelConfig.CompressorConfig.TargetFrameSize = 24
+	channelConfig.CompressorConfig.ApproxComprRatio = 0
 
 	// Continuously add blocks until the max frame index is reached
 	// This should cause the [channelBuilder.OutputFrames] function
@@ -546,9 +550,9 @@ func TestChannelBuilder_AddBlock(t *testing.T) {
 	channelConfig.MaxFrameSize = 30
 
 	// Configure the Input Threshold params so we observe a full channel
-	channelConfig.TargetFrameSize = 30
-	channelConfig.TargetNumFrames = 2
-	channelConfig.ApproxComprRatio = 1
+	channelConfig.CompressorConfig.TargetFrameSize = 30
+	channelConfig.CompressorConfig.TargetNumFrames = 2
+	channelConfig.CompressorConfig.ApproxComprRatio = 1
 
 	// Construct the channel builder
 	cb, err := newChannelBuilder(channelConfig)
@@ -703,10 +707,10 @@ func TestChannelBuilder_OutputBytes(t *testing.T) {
 	require := require.New(t)
 	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
 	cfg := defaultTestChannelConfig
-	cfg.TargetFrameSize = 1000
+	cfg.CompressorConfig.TargetFrameSize = 1000
 	cfg.MaxFrameSize = 1000
-	cfg.TargetNumFrames = 16
-	cfg.ApproxComprRatio = 1.0
+	cfg.CompressorConfig.TargetNumFrames = 16
+	cfg.CompressorConfig.ApproxComprRatio = 1.0
 	cb, err := newChannelBuilder(cfg)
 	require.NoError(err, "newChannelBuilder")
 

op-batcher/batcher/channel_manager_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
@@ -98,9 +99,12 @@ func TestChannelManagerReturnsErrReorgWhenDrained(t *testing.T) {
 	log := testlog.Logger(t, log.LvlCrit)
 	m := NewChannelManager(log, metrics.NoopMetrics,
 		ChannelConfig{
-			TargetFrameSize:  0,
 			MaxFrameSize: 120_000,
+			CompressorConfig: compressor.Config{
+				TargetFrameSize:  0,
 				ApproxComprRatio: 1.0,
+			},
+			CompressorFactory: compressor.NewRatioCompressor,
 		})
 
 	a := newMiniL2Block(0)
@@ -171,9 +175,12 @@ func TestChannelManager_Clear(t *testing.T) {
 		// Have to set the max frame size here otherwise the channel builder would not
 		// be able to output any frames
 		MaxFrameSize: 24,
+		CompressorConfig: compressor.Config{
 			TargetFrameSize:  24,
 			TargetNumFrames:  1,
 			ApproxComprRatio: 1.0,
+		},
+		CompressorFactory: compressor.NewRatioCompressor,
 	})
 
 	// Channel Manager state should be empty by default
@@ -332,9 +339,12 @@ func TestChannelManager_TxResend(t *testing.T) {
 	log := testlog.Logger(t, log.LvlError)
 	m := NewChannelManager(log, metrics.NoopMetrics,
 		ChannelConfig{
-			TargetFrameSize:  0,
 			MaxFrameSize: 120_000,
+			CompressorConfig: compressor.Config{
+				TargetFrameSize:  0,
 				ApproxComprRatio: 1.0,
+			},
+			CompressorFactory: compressor.NewRatioCompressor,
 		})
 
 	a, _ := derivetest.RandomL2Block(rng, 4)
@@ -373,10 +383,13 @@ func TestChannelManagerCloseBeforeFirstUse(t *testing.T) {
 	log := testlog.Logger(t, log.LvlCrit)
 	m := NewChannelManager(log, metrics.NoopMetrics,
 		ChannelConfig{
-			TargetFrameSize:  0,
 			MaxFrameSize:   100,
-			ApproxComprRatio: 1.0,
 			ChannelTimeout: 1000,
+			CompressorConfig: compressor.Config{
+				TargetFrameSize:  0,
+				ApproxComprRatio: 1.0,
+			},
+			CompressorFactory: compressor.NewRatioCompressor,
 		})
 
 	a, _ := derivetest.RandomL2Block(rng, 4)
@@ -398,11 +411,14 @@ func TestChannelManagerCloseNoPendingChannel(t *testing.T) {
 	log := testlog.Logger(t, log.LvlCrit)
 	m := NewChannelManager(log, metrics.NoopMetrics,
 		ChannelConfig{
+			MaxFrameSize:   100,
+			ChannelTimeout: 1000,
+			CompressorConfig: compressor.Config{
 				TargetFrameSize:  1,
 				TargetNumFrames:  1,
-			MaxFrameSize:     100,
 				ApproxComprRatio: 1.0,
-			ChannelTimeout:   1000,
+			},
+			CompressorFactory: compressor.NewRatioCompressor,
 		})
 	a := newMiniL2Block(0)
 	b := newMiniL2BlockWithNumberParent(0, big.NewInt(1), a.Hash())
@@ -435,11 +451,14 @@ func TestChannelManagerClosePendingChannel(t *testing.T) {
 	log := testlog.Logger(t, log.LvlCrit)
 	m := NewChannelManager(log, metrics.NoopMetrics,
 		ChannelConfig{
+			MaxFrameSize:   1000,
+			ChannelTimeout: 1000,
+			CompressorConfig: compressor.Config{
 				TargetNumFrames:  100,
 				TargetFrameSize:  1000,
-			MaxFrameSize:     1000,
 				ApproxComprRatio: 1.0,
-			ChannelTimeout:   1000,
+			},
+			CompressorFactory: compressor.NewRatioCompressor,
 		})
 
 	a := newMiniL2Block(50_000)
@@ -478,11 +497,14 @@ func TestChannelManagerCloseAllTxsFailed(t *testing.T) {
 	log := testlog.Logger(t, log.LvlCrit)
 	m := NewChannelManager(log, metrics.NoopMetrics,
 		ChannelConfig{
+			MaxFrameSize:   1000,
+			ChannelTimeout: 1000,
+			CompressorConfig: compressor.Config{
 				TargetNumFrames:  100,
 				TargetFrameSize:  1000,
-			MaxFrameSize:     1000,
 				ApproxComprRatio: 1.0,
-			ChannelTimeout:   1000,
+			},
+			CompressorFactory: compressor.NewRatioCompressor,
 		})
 
 	a := newMiniL2Block(50_000)

op-batcher/batcher/config.go

 package batcher
 
 import (
-	"strings"
 	"time"
 
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli"
 
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/ethereum-optimism/optimism/op-batcher/flags"
 	"github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-batcher/rpc"
@@ -85,19 +85,6 @@ type CLIConfig struct {
 	// MaxL1TxSize is the maximum size of a batch tx submitted to L1.
 	MaxL1TxSize uint64
 
-	// TargetL1TxSize is the target size of a batch tx submitted to L1.
-	TargetL1TxSize uint64
-
-	// TargetNumFrames is the target number of frames per channel.
-	TargetNumFrames int
-
-	// ApproxComprRatio is the approximate compression ratio (<= 1.0) of the used
-	// compression algorithm.
-	ApproxComprRatio float64
-
-	// CompressorKind is the compressor implementation to use.
-	CompressorKind flags.CompressorKind
-
 	Stopped bool
 
 	TxMgrConfig      txmgr.CLIConfig
@@ -105,6 +92,7 @@ type CLIConfig struct {
 	LogConfig        oplog.CLIConfig
 	MetricsConfig    opmetrics.CLIConfig
 	PprofConfig      oppprof.CLIConfig
+	CompressorConfig compressor.CLIConfig
 }
 
 func (c CLIConfig) Check() error {
@@ -123,6 +111,9 @@ func (c CLIConfig) Check() error {
 	if err := c.TxMgrConfig.Check(); err != nil {
 		return err
 	}
+	if err := c.CompressorConfig.Check(); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -140,15 +131,12 @@ func NewConfig(ctx *cli.Context) CLIConfig {
 		MaxPendingTransactions: ctx.GlobalUint64(flags.MaxPendingTransactionsFlag.Name),
 		MaxChannelDuration:     ctx.GlobalUint64(flags.MaxChannelDurationFlag.Name),
 		MaxL1TxSize:            ctx.GlobalUint64(flags.MaxL1TxSizeBytesFlag.Name),
-		TargetL1TxSize:         ctx.GlobalUint64(flags.TargetL1TxSizeBytesFlag.Name),
-		TargetNumFrames:        ctx.GlobalInt(flags.TargetNumFramesFlag.Name),
-		ApproxComprRatio:       ctx.GlobalFloat64(flags.ApproxComprRatioFlag.Name),
-		CompressorKind:         flags.CompressorKind(strings.ToLower(ctx.GlobalString(flags.CompressorFlag.Name))),
 		Stopped:                ctx.GlobalBool(flags.StoppedFlag.Name),
 		TxMgrConfig:            txmgr.ReadCLIConfig(ctx),
 		RPCConfig:              rpc.ReadCLIConfig(ctx),
 		LogConfig:              oplog.ReadCLIConfig(ctx),
 		MetricsConfig:          opmetrics.ReadCLIConfig(ctx),
 		PprofConfig:            oppprof.ReadCLIConfig(ctx),
+		CompressorConfig:       compressor.ReadCLIConfig(ctx),
 	}
 }

op-batcher/batcher/driver.go

@@ -75,6 +75,11 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 		return nil, err
 	}
 
+	compressorFactory, err := cfg.CompressorConfig.Factory()
+	if err != nil {
+		return nil, err
+	}
+
 	batcherCfg := Config{
 		L1Client:               l1Client,
 		L2Client:               l2Client,
@@ -90,10 +95,8 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 			MaxChannelDuration: cfg.MaxChannelDuration,
 			SubSafetyMargin:    cfg.SubSafetyMargin,
 			MaxFrameSize:       cfg.MaxL1TxSize - 1, // subtract 1 byte for version
-			TargetFrameSize:    cfg.TargetL1TxSize - 1, // subtract 1 byte for version
-			TargetNumFrames:    cfg.TargetNumFrames,
-			ApproxComprRatio:   cfg.ApproxComprRatio,
-			CompressorKind:     cfg.CompressorKind,
+			CompressorConfig:   cfg.CompressorConfig.Config,
+			CompressorFactory:  compressorFactory,
 		},
 	}
 

op-batcher/compressor/cli.go

+package compressor
+
+import (
+	"fmt"
+
+	opservice "github.com/ethereum-optimism/optimism/op-service"
+	"github.com/urfave/cli"
+)
+
+const (
+	TargetL1TxSizeBytesFlagName = "target-l1-tx-size-bytes"
+	TargetNumFramesFlagName     = "target-num-frames"
+	ApproxComprRatioFlagName    = "approx-compr-ratio"
+	TypeFlagName                = "compressor"
+)
+
+func CLIFlags(envPrefix string) []cli.Flag {
+	return []cli.Flag{
+		cli.Uint64Flag{
+			Name:   TargetL1TxSizeBytesFlagName,
+			Usage:  "The target size of a batch tx submitted to L1.",
+			Value:  100_000,
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "TARGET_L1_TX_SIZE_BYTES"),
+		},
+		cli.IntFlag{
+			Name:   TargetNumFramesFlagName,
+			Usage:  "The target number of frames to create per channel",
+			Value:  1,
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "TARGET_NUM_FRAMES"),
+		},
+		cli.Float64Flag{
+			Name:   ApproxComprRatioFlagName,
+			Usage:  "The approximate compression ratio (<= 1.0)",
+			Value:  0.4,
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "APPROX_COMPR_RATIO"),
+		},
+		cli.StringFlag{
+			Name:   TypeFlagName,
+			Usage:  "The type of compressor. Valid options: " + FactoryFlags(),
+			EnvVar: opservice.PrefixEnvVar(envPrefix, "COMPRESSOR"),
+			Value:  Ratio.FlagValue,
+		},
+	}
+}
+
+type CLIConfig struct {
+	Type   string
+	Config Config
+}
+
+func (c *CLIConfig) Check() error {
+	_, err := c.Factory()
+	return err
+}
+
+func (c *CLIConfig) Factory() (FactoryFunc, error) {
+	for _, f := range Factories {
+		if f.FlagValue == c.Type {
+			return f.FactoryFunc, nil
+		}
+	}
+	return nil, fmt.Errorf("unknown compressor kind: %q", c.Type)
+}
+
+func ReadCLIConfig(ctx *cli.Context) CLIConfig {
+	return CLIConfig{
+		Type: ctx.GlobalString(TypeFlagName),
+		Config: Config{
+			TargetFrameSize:  ctx.GlobalUint64(TargetL1TxSizeBytesFlagName) - 1, // subtract 1 byte for version,
+			TargetNumFrames:  ctx.GlobalInt(TargetNumFramesFlagName),
+			ApproxComprRatio: ctx.GlobalFloat64(ApproxComprRatioFlagName),
+		},
+	}
+}

op-batcher/compressor/config.go

+package compressor
+
+type Config struct {
+	// FrameSizeTarget to target when creating channel frames. Note that if the
+	// realized compression ratio is worse than the approximate, more frames may
+	// actually be created. This also depends on how close the target is to the
+	// max frame size.
+	TargetFrameSize uint64
+	// NumFramesTarget to create in this channel. If the realized compression ratio
+	// is worse than approxComprRatio, additional leftover frame(s) might get created.
+	TargetNumFrames int
+	// ApproxCompRatio to assume. Should be slightly smaller than average from
+	// experiments to avoid the chances of creating a small additional leftover frame.
+	ApproxComprRatio float64
+}

op-batcher/compressor/factory.go

+package compressor
+
+import (
+	"strings"
+
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+)
+
+type FactoryFunc func(Config) (derive.Compressor, error)
+
+type FactoryFlag struct {
+	FlagValue   string
+	FactoryFunc FactoryFunc
+}
+
+var (
+	// The Ratio Factory creates new RatioCompressor's (see NewRatioCompressor
+	// for a description).
+	Ratio = FactoryFlag{
+		FlagValue:   "ratio",
+		FactoryFunc: NewRatioCompressor,
+	}
+	// The Shadow Factory creates new ShadowCompressor's (see NewShadowCompressor
+	// for a description).
+	Shadow = FactoryFlag{
+		FlagValue:   "shadow",
+		FactoryFunc: NewShadowCompressor,
+	}
+)
+
+var Factories = []FactoryFlag{
+	Ratio,
+	Shadow,
+}
+
+func FactoryFlags() string {
+	var out strings.Builder
+	for i, v := range Factories {
+		out.WriteString(v.FlagValue)
+		if i+1 < len(Factories) {
+			out.WriteString(", ")
+		}
+	}
+	return out.String()
+}

op-batcher/batcher/ratio_compressor.go → op-batcher/compressor/ratio_compressor.go

-package batcher
+package compressor
 
 import (
 	"bytes"
@@ -8,19 +8,7 @@ import (
 )
 
 type RatioCompressor struct {
-	// The frame size to target when creating channel frames. Note that if the
-	// realized compression ratio is worse than the approximate, more frames may
-	// actually be created. This also depends on how close TargetFrameSize is to
-	// MaxFrameSize.
-	TargetFrameSize uint64
-	// The target number of frames to create in this channel. If the realized
-	// compression ratio is worse than approxComprRatio, additional leftover
-	// frame(s) might get created.
-	TargetNumFrames int
-	// Approximated compression ratio to assume. Should be slightly smaller than
-	// average from experiments to avoid the chances of creating a small
-	// additional leftover frame.
-	ApproxComprRatio float64
+	config Config
 
 	inputBytes int
 	buf        bytes.Buffer
@@ -32,11 +20,9 @@ type RatioCompressor struct {
 // the compressor before it's considered full. The full calculation is as follows:
 //
 //	full = uncompressedLength * approxCompRatio >= targetFrameSize * targetNumFrames
-func NewRatioCompressor(targetFrameSize uint64, targetNumFrames int, approxCompRatio float64) (derive.Compressor, error) {
+func NewRatioCompressor(config Config) (derive.Compressor, error) {
 	c := &RatioCompressor{
-		TargetFrameSize:  targetFrameSize,
-		TargetNumFrames:  targetNumFrames,
-		ApproxComprRatio: approxCompRatio,
+		config: config,
 	}
 
 	compress, err := zlib.NewWriterLevel(&c.buf, zlib.BestCompression)
@@ -88,7 +74,7 @@ func (t *RatioCompressor) FullErr() error {
 // InputThreshold calculates the input data threshold in bytes from the given
 // parameters.
 func (t *RatioCompressor) InputThreshold() uint64 {
-	return uint64(float64(t.TargetNumFrames) * float64(t.TargetFrameSize) / t.ApproxComprRatio)
+	return uint64(float64(t.config.TargetNumFrames) * float64(t.config.TargetFrameSize) / t.config.ApproxComprRatio)
 }
 
 // inputTargetReached says whether the target amount of input data has been

op-batcher/batcher/ratio_compressor_test.go → op-batcher/compressor/ratio_compressor_test.go

-package batcher_test
+package compressor_test
 
 import (
 	"math"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-batcher/batcher"
-	"github.com/ethereum-optimism/optimism/op-batcher/flags"
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/stretchr/testify/require"
 )
 
@@ -119,15 +118,13 @@ func TestInputThreshold(t *testing.T) {
 
 	// Validate each test case
 	for _, tt := range tests {
-		config := batcher.ChannelConfig{
+		comp, err := compressor.NewRatioCompressor(compressor.Config{
 			TargetFrameSize:  tt.input.TargetFrameSize,
 			TargetNumFrames:  tt.input.TargetNumFrames,
 			ApproxComprRatio: tt.input.ApproxComprRatio,
-			CompressorKind:   flags.RatioCompressorKind,
-		}
-		comp, err := config.NewCompressor()
+		})
 		require.NoError(t, err)
-		got := comp.(*batcher.RatioCompressor).InputThreshold()
+		got := comp.(*compressor.RatioCompressor).InputThreshold()
 		tt.assertion(got)
 	}
 }

op-batcher/batcher/shadow_compressor.go → op-batcher/compressor/shadow_compressor.go

-package batcher
+package compressor
 
 import (
 	"bytes"
@@ -8,14 +8,7 @@ import (
 )
 
 type ShadowCompressor struct {
-	// The frame size to target when creating channel frames. When adding new
-	// data to the shadow compressor causes the buffer size to be greater than
-	// the target size, the compressor is marked as full.
-	TargetFrameSize uint64
-	// The target number of frames to create in this channel. If the realized
-	// compression ratio is worse than approxComprRatio, additional leftover
-	// frame(s) might get created.
-	TargetNumFrames int
+	config Config
 
 	buf      bytes.Buffer
 	compress *zlib.Writer
@@ -33,10 +26,9 @@ type ShadowCompressor struct {
 // exception to this rule: the first write to the buffer is not checked against the
 // target, which allows individual blocks larger than the target to be included (and will
 // be split across multiple channel frames).
-func NewShadowCompressor(targetFrameSize uint64, targetNumFrames int) (derive.Compressor, error) {
+func NewShadowCompressor(config Config) (derive.Compressor, error) {
 	c := &ShadowCompressor{
-		TargetFrameSize: targetFrameSize,
-		TargetNumFrames: targetNumFrames,
+		config: config,
 	}
 
 	var err error
@@ -61,7 +53,7 @@ func (t *ShadowCompressor) Write(p []byte) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	if uint64(t.shadowBuf.Len()) > t.TargetFrameSize*uint64(t.TargetNumFrames) {
+	if uint64(t.shadowBuf.Len()) > t.config.TargetFrameSize*uint64(t.config.TargetNumFrames) {
 		t.fullErr = derive.CompressorFullErr
 		if t.Len() > 0 {
 			// only return an error if we've already written data to this compressor before

op-batcher/batcher/shadow_compressor_test.go → op-batcher/compressor/shadow_compressor_test.go

-package batcher_test
+package compressor_test
 
 import (
 	"bytes"
@@ -7,7 +7,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-batcher/batcher"
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/stretchr/testify/require"
 )
@@ -64,7 +64,10 @@ func TestShadowCompressor(t *testing.T) {
 			t.Parallel()
 			require.Equal(t, len(test.errs), len(test.data), "invalid test case: len(data) != len(errs)")
 
-			sc, err := batcher.NewShadowCompressor(test.targetFrameSize, test.targetNumFrames)
+			sc, err := compressor.NewShadowCompressor(compressor.Config{
+				TargetFrameSize: test.targetFrameSize,
+				TargetNumFrames: test.targetNumFrames,
+			})
 			require.NoError(t, err)
 
 			for i, d := range test.data {

op-batcher/flags/flags.go

@@ -6,8 +6,8 @@ import (
 
 	"github.com/urfave/cli"
 
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/ethereum-optimism/optimism/op-batcher/rpc"
-	"github.com/ethereum-optimism/optimism/op-node/flags"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
@@ -68,34 +68,6 @@ var (
 		Value:  120_000,
 		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "MAX_L1_TX_SIZE_BYTES"),
 	}
-	TargetL1TxSizeBytesFlag = cli.Uint64Flag{
-		Name:   "target-l1-tx-size-bytes",
-		Usage:  "The target size of a batch tx submitted to L1.",
-		Value:  100_000,
-		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "TARGET_L1_TX_SIZE_BYTES"),
-	}
-	TargetNumFramesFlag = cli.IntFlag{
-		Name:   "target-num-frames",
-		Usage:  "The target number of frames to create per channel",
-		Value:  1,
-		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "TARGET_NUM_FRAMES"),
-	}
-	ApproxComprRatioFlag = cli.Float64Flag{
-		Name:   "approx-compr-ratio",
-		Usage:  "The approximate compression ratio (<= 1.0)",
-		Value:  0.4,
-		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "APPROX_COMPR_RATIO"),
-	}
-	CompressorFlag = cli.GenericFlag{
-		Name: "compressor",
-		Usage: "The type of compressor. Valid options: " +
-			flags.EnumString[CompressorKind](CompressorKinds),
-		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "COMPRESSOR"),
-		Value: func() *CompressorKind {
-			out := RatioCompressorKind
-			return &out
-		}(),
-	}
 	StoppedFlag = cli.BoolFlag{
 		Name:   "stopped",
 		Usage:  "Initialize the batcher in a stopped state. The batcher can be started using the admin_startBatcher RPC",
@@ -117,10 +89,6 @@ var optionalFlags = []cli.Flag{
 	MaxPendingTransactionsFlag,
 	MaxChannelDurationFlag,
 	MaxL1TxSizeBytesFlag,
-	TargetL1TxSizeBytesFlag,
-	TargetNumFramesFlag,
-	ApproxComprRatioFlag,
-	CompressorFlag,
 	StoppedFlag,
 	SequencerHDPathFlag,
 }
@@ -132,6 +100,7 @@ func init() {
 	optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
 	optionalFlags = append(optionalFlags, rpc.CLIFlags(EnvVarPrefix)...)
 	optionalFlags = append(optionalFlags, txmgr.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, compressor.CLIFlags(EnvVarPrefix)...)
 
 	Flags = append(requiredFlags, optionalFlags...)
 }
@@ -147,41 +116,3 @@ func CheckRequired(ctx *cli.Context) error {
 	}
 	return nil
 }
-
-// CompressorKind identifies a compressor implementation.
-type CompressorKind string
-
-const (
-	// The RatioCompressorKind kind selects the batcher.RatioCompressor (see
-	// batcher.NewRatioCompressor for a description).
-	RatioCompressorKind CompressorKind = "ratio"
-	// The ShadowCompressorKind kind selects the batcher.ShadowCompressor (see
-	// batcher.NewShadowCompressor for a description).
-	ShadowCompressorKind CompressorKind = "shadow"
-)
-
-var CompressorKinds = []CompressorKind{
-	RatioCompressorKind,
-	ShadowCompressorKind,
-}
-
-func (kind CompressorKind) String() string {
-	return string(kind)
-}
-
-func (kind *CompressorKind) Set(value string) error {
-	if !ValidCompressorKind(CompressorKind(value)) {
-		return fmt.Errorf("unknown compressor kind: %q", value)
-	}
-	*kind = CompressorKind(value)
-	return nil
-}
-
-func ValidCompressorKind(value CompressorKind) bool {
-	for _, k := range CompressorKinds {
-		if k == value {
-			return true
-		}
-	}
-	return false
-}

op-e2e/migration_test.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	bss "github.com/ethereum-optimism/optimism/op-batcher/batcher"
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	batchermetrics "github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
@@ -335,9 +336,14 @@ func TestMigration(t *testing.T) {
 		RollupRpc:          rollupNode.HTTPEndpoint(),
 		MaxChannelDuration: 1,
 		MaxL1TxSize:        120_000,
-		TargetL1TxSize:     100_000,
+		CompressorConfig: compressor.CLIConfig{
+			Type: compressor.Ratio.FlagValue,
+			Config: compressor.Config{
+				TargetFrameSize:  100_000 - 1,
 				TargetNumFrames:  1,
 				ApproxComprRatio: 0.4,
+			},
+		},
 		SubSafetyMargin: 4,
 		PollInterval:    50 * time.Millisecond,
 		TxMgrConfig:     newTxMgrConfig(forkedL1URL, secrets.Batcher),

op-e2e/setup.go

@@ -24,6 +24,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	bss "github.com/ethereum-optimism/optimism/op-batcher/batcher"
+	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	batchermetrics "github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
@@ -599,9 +600,14 @@ func (cfg SystemConfig) Start(_opts ...SystemConfigOption) (*System, error) {
 		MaxPendingTransactions: 1,
 		MaxChannelDuration:     1,
 		MaxL1TxSize:            120_000,
-		TargetL1TxSize:         100_000,
+		CompressorConfig: compressor.CLIConfig{
+			Type: compressor.Ratio.FlagValue,
+			Config: compressor.Config{
+				TargetFrameSize:  100_000 - 1,
 				TargetNumFrames:  1,
 				ApproxComprRatio: 0.4,
+			},
+		},
 		SubSafetyMargin: 4,
 		PollInterval:    50 * time.Millisecond,
 		TxMgrConfig:     newTxMgrConfig(sys.Nodes["l1"].WSEndpoint(), cfg.Secrets.Batcher),