op-batcher,e2e: Add MaxChannelDuration parameter to batcher

And reconfigure tests to set this to 1. The target tx size can finally
be set to a proper value (100k) and the compression ratio as well to our
currently best estimate of 0.4.

The respective environment variable is OP_BATCHER_MAX_CHANNEL_DURATION.

op-batcher/batcher/config.go

@@ -47,6 +47,13 @@ type CLIConfig struct {
 	// RollupRpc is the HTTP provider URL for the L2 rollup node.
 	RollupRpc string
 
+	// MaxChannelDuration is the maximum duration (in #L1-blocks) to keep the
+	// channel open. This allows control over how long a channel is kept open
+	// during times of low transaction volume.
+	//
+	// If 0, duration checks are disabled.
+	MaxChannelDuration uint64
+
 	// The batcher tx submission safety margin (in #L1-blocks) to subtract from
 	// a channel's timeout and sequencing window, to guarantee safe inclusion of
 	// a channel on L1.
@@ -143,18 +150,19 @@ func NewConfig(ctx *cli.Context) CLIConfig {
 		ResubmissionTimeout:       ctx.GlobalDuration(flags.ResubmissionTimeoutFlag.Name),
 
 		/* Optional Flags */
-		MaxL1TxSize:      ctx.GlobalUint64(flags.MaxL1TxSizeBytesFlag.Name),
-		TargetL1TxSize:   ctx.GlobalUint64(flags.TargetL1TxSizeBytesFlag.Name),
-		TargetNumFrames:  ctx.GlobalInt(flags.TargetNumFramesFlag.Name),
-		ApproxComprRatio: ctx.GlobalFloat64(flags.ApproxComprRatioFlag.Name),
-		Stopped:          ctx.GlobalBool(flags.StoppedFlag.Name),
-		Mnemonic:         ctx.GlobalString(flags.MnemonicFlag.Name),
-		SequencerHDPath:  ctx.GlobalString(flags.SequencerHDPathFlag.Name),
-		PrivateKey:       ctx.GlobalString(flags.PrivateKeyFlag.Name),
-		RPCConfig:        rpc.ReadCLIConfig(ctx),
-		LogConfig:        oplog.ReadCLIConfig(ctx),
-		MetricsConfig:    opmetrics.ReadCLIConfig(ctx),
-		PprofConfig:      oppprof.ReadCLIConfig(ctx),
-		SignerConfig:     opsigner.ReadCLIConfig(ctx),
+		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),
+		Stopped:            ctx.GlobalBool(flags.StoppedFlag.Name),
+		Mnemonic:           ctx.GlobalString(flags.MnemonicFlag.Name),
+		SequencerHDPath:    ctx.GlobalString(flags.SequencerHDPathFlag.Name),
+		PrivateKey:         ctx.GlobalString(flags.PrivateKeyFlag.Name),
+		RPCConfig:          rpc.ReadCLIConfig(ctx),
+		LogConfig:          oplog.ReadCLIConfig(ctx),
+		MetricsConfig:      opmetrics.ReadCLIConfig(ctx),
+		PprofConfig:        oppprof.ReadCLIConfig(ctx),
+		SignerConfig:       opsigner.ReadCLIConfig(ctx),
 	}
 }

op-batcher/batcher/driver.go

@@ -88,13 +88,14 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger) (*BatchSubmitte
 		From:            fromAddress,
 		Rollup:          rcfg,
 		Channel: ChannelConfig{
-			SeqWindowSize:    rcfg.SeqWindowSize,
-			ChannelTimeout:   rcfg.ChannelTimeout,
-			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,
+			SeqWindowSize:      rcfg.SeqWindowSize,
+			ChannelTimeout:     rcfg.ChannelTimeout,
+			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,
 		},
 	}
 

op-batcher/flags/flags.go

@@ -75,6 +75,12 @@ var (
 
 	/* Optional flags */
 
+	MaxChannelDurationFlag = cli.Uint64Flag{
+		Name:   "max-channel-duration",
+		Usage:  "The maximum duration of L1-blocks to keep a channel open. 0 to disable.",
+		Value:  0,
+		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "MAX_CHANNEL_DURATION"),
+	}
 	MaxL1TxSizeBytesFlag = cli.Uint64Flag{
 		Name:   "max-l1-tx-size-bytes",
 		Usage:  "The maximum size of a batch tx submitted to L1.",
@@ -96,7 +102,7 @@ var (
 	ApproxComprRatioFlag = cli.Float64Flag{
 		Name:   "approx-compr-ratio",
 		Usage:  "The approximate compression ratio (<= 1.0)",
-		Value:  1.0,
+		Value:  0.4,
 		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "APPROX_COMPR_RATIO"),
 	}
 	StoppedFlag = cli.BoolFlag{
@@ -135,6 +141,7 @@ var requiredFlags = []cli.Flag{
 }
 
 var optionalFlags = []cli.Flag{
+	MaxChannelDurationFlag,
 	MaxL1TxSizeBytesFlag,
 	TargetL1TxSizeBytesFlag,
 	TargetNumFramesFlag,

op-e2e/migration_test.go

@@ -323,11 +323,12 @@ func TestMigration(t *testing.T) {
 		L1EthRpc:                  forkedL1URL,
 		L2EthRpc:                  gethNode.WSEndpoint(),
 		RollupRpc:                 rollupNode.HTTPEndpoint(),
+		MaxChannelDuration:        1,
 		MaxL1TxSize:               120_000,
-		TargetL1TxSize:            624,
+		TargetL1TxSize:            100_000,
 		TargetNumFrames:           1,
-		ApproxComprRatio:          1.0,
-		SubSafetyMargin:           testSafetyMargin(deployCfg),
+		ApproxComprRatio:          0.4,
+		SubSafetyMargin:           4,
 		PollInterval:              50 * time.Millisecond,
 		NumConfirmations:          1,
 		ResubmissionTimeout:       5 * time.Second,

op-e2e/setup.go

@@ -531,11 +531,12 @@ func (cfg SystemConfig) Start() (*System, error) {
 		L1EthRpc:                  sys.Nodes["l1"].WSEndpoint(),
 		L2EthRpc:                  sys.Nodes["sequencer"].WSEndpoint(),
 		RollupRpc:                 sys.RollupNodes["sequencer"].HTTPEndpoint(),
+		MaxChannelDuration:        1,
 		MaxL1TxSize:               120_000,
-		TargetL1TxSize:            160, //624,
+		TargetL1TxSize:            100_000,
 		TargetNumFrames:           1,
-		ApproxComprRatio:          1.0,
-		SubSafetyMargin:           testSafetyMargin(cfg.DeployConfig),
+		ApproxComprRatio:          0.4,
+		SubSafetyMargin:           4,
 		PollInterval:              50 * time.Millisecond,
 		NumConfirmations:          1,
 		ResubmissionTimeout:       5 * time.Second,
@@ -575,24 +576,3 @@ func hexPriv(in *ecdsa.PrivateKey) string {
 	b := e2eutils.EncodePrivKey(in)
 	return hexutil.Encode(b)
 }
-
-// returns a safety margin that heuristically leads to a short channel lifetime
-// of netChannelDuration. In current testing setups, we want channels to close
-// quickly to have a low latency. We don't optimize for gas consumption.
-func testSafetyMargin(cfg *genesis.DeployConfig) uint64 {
-	// target channel duration after first frame is included on L1
-	const netChannelDuration = 2
-	// The sequencing window timeout starts from the L1 origin, whereas the
-	// channel timeout starts from the first L1 inclusion block of any frame.
-	// So to have comparable values, the sws is converted to an effective
-	// sequencing window from the first L1 inclusion block, assuming that L2
-	// blocks are quickly included on L1.
-	// So we subtract 1 block distance from the origin block and 1 block for
-	// minging the first frame.
-	openChannelSeqWindow := cfg.SequencerWindowSize - 2
-	if openChannelSeqWindow > cfg.ChannelTimeout {
-		return cfg.ChannelTimeout - netChannelDuration
-	} else {
-		return openChannelSeqWindow - netChannelDuration
-	}
-}

ops-bedrock/docker-compose.yml

@@ -120,11 +120,12 @@ services:
       OP_BATCHER_L1_ETH_RPC: http://l1:8545
       OP_BATCHER_L2_ETH_RPC: http://l2:8545
       OP_BATCHER_ROLLUP_RPC: http://op-node:8545
+      OP_BATCHER_MAX_CHANNEL_DURATION: 1
       OP_BATCHER_MAX_L1_TX_SIZE_BYTES: 120000
-      OP_BATCHER_TARGET_L1_TX_SIZE_BYTES: 624
+      OP_BATCHER_TARGET_L1_TX_SIZE_BYTES: 100000
       OP_BATCHER_TARGET_NUM_FRAMES: 1
-      OP_BATCHER_APPROX_COMPR_RATIO: 1.0
-      OP_BATCHER_SUB_SAFETY_MARGIN: 6 # SWS is 15, ChannelTimeout is 40
+      OP_BATCHER_APPROX_COMPR_RATIO: 0.4
+      OP_BATCHER_SUB_SAFETY_MARGIN: 4 # SWS is 15, ChannelTimeout is 40
       OP_BATCHER_POLL_INTERVAL: 1s
       OP_BATCHER_NUM_CONFIRMATIONS: 1
       OP_BATCHER_SAFE_ABORT_NONCE_TOO_LOW_COUNT: 3