feat: add go/batch-submitter envvar parsing

go/batch-submitter/cmd/batch-submitter/main.go

+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/urfave/cli"
+
+	batchsubmitter "github.com/ethereum-optimism/go/batch-submitter"
+	"github.com/ethereum-optimism/go/batch-submitter/flags"
+)
+
+var (
+	GitVersion = ""
+	GitCommit  = ""
+	GitDate    = ""
+)
+
+func main() {
+	// Set up logger with a default INFO level in case we fail to parse flags.
+	// Otherwise the final crtiical log won't show what the parsing error was.
+	log.Root().SetHandler(
+		log.LvlFilterHandler(
+			log.LvlInfo,
+			log.StreamHandler(os.Stdout, log.TerminalFormat(true)),
+		),
+	)
+
+	app := cli.NewApp()
+	app.Flags = flags.Flags
+	app.Version = fmt.Sprintf("%s-%s", GitVersion, params.VersionWithCommit(GitCommit, GitDate))
+	app.Name = "batch-submitter"
+	app.Usage = "Batch Submitter Service"
+	app.Description = "Service for generating and submitting batched transactions " +
+		"that synchronize L2 state to L1 contracts"
+
+	app.Action = func(ctx *cli.Context) error {
+		cfg, err := batchsubmitter.NewConfig(ctx)
+		if err != nil {
+			return err
+		}
+
+		logLevel, err := log.LvlFromString(cfg.LogLevel)
+		if err != nil {
+			return err
+		}
+
+		log.Root().SetHandler(
+			log.LvlFilterHandler(
+				logLevel,
+				log.StreamHandler(os.Stdout, log.TerminalFormat(true)),
+			),
+		)
+
+		log.Info("Config", "message", fmt.Sprintf("%#v", cfg))
+		return nil
+	}
+	err := app.Run(os.Args)
+	if err != nil {
+		log.Crit("Application failed", "message", err)
+	}
+}

go/batch-submitter/config.go

+package batchsubmitter
+
+import (
+	"errors"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/urfave/cli"
+
+	"github.com/ethereum-optimism/go/batch-submitter/flags"
+)
+
+var (
+	// ErrSequencerPrivKeyOrMnemonic signals that the user tried to set both
+	// sequencer wallet derivation methods or neither of them.
+	ErrSequencerPrivKeyOrMnemonic = errors.New("either sequencer-private-key " +
+		"or mnemonic + sequencer-hd-path must be set")
+
+	// ErrProposererPrivKeyOrMnemonic signals that the user tried to set
+	// both proposer wallet derivation methods or neither of them.
+	ErrProposerPrivKeyOrMnemonic = errors.New("either proposer-private-key " +
+		"or mnemonic + proposer-hd-path must be set")
+
+	// ErrSameSequencerAndProposerHDPath signals that the user specified the
+	// same sequencer and proposer derivations paths, which otherwise would
+	// lead to the two using the same wallet.
+	ErrSameSequencerAndProposerHDPath = errors.New("sequencer-hd-path and " +
+		"proposer-hd-path must be distinct when using mnemonic")
+
+	// ErrSameSequencerAndProposerPrivKey signals that the user specified
+	// the same sequencer and proposer private keys, which otherwise would
+	// lead to the two using the same wallet.
+	ErrSameSequencerAndProposerPrivKey = errors.New("sequencer-priv-key and " +
+		"proposer-priv-key must be distinct")
+
+	// ErrSentryDSNNotSet signals that not Data Source Name was provided
+	// with which to configure Sentry logging.
+	ErrSentryDSNNotSet = errors.New("sentry-dsn must be set if use-sentry " +
+		"is true")
+)
+
+type Config struct {
+	/* Required Params */
+
+	// BuildEnv identifies the environment this binary is intended for, i.e.
+	// production, development, etc.
+	BuildEnv string
+
+	// EthNetworkName identifies the intended Ethereum network.
+	EthNetworkName string
+
+	// L1EthRpc is the HTTP provider URL for L1.
+	L1EthRpc string
+
+	// L2EthRpc is the HTTP provider URL for L1.
+	L2EthRpc string
+
+	// CTCAddress is the CTC contract address.
+	CTCAddress string
+
+	// SCCAddress is the SCC contract address.
+	SCCAddress string
+
+	// MinL1TxSize is the minimum size in bytes of any L1 transactions generated
+	// by the batch submitter.
+	MinL1TxSize uint64
+
+	// MaxL1TxSize is the maximum size in bytes of any L1 transactions generated
+	// by the batch submitter.
+	MaxL1TxSize uint64
+
+	// MaxTxBatchCount is the maximum number of L2 transactions that can ever be
+	// in a batch.
+	MaxTxBatchCount uint64
+
+	// MaxStateBatchCount is the maximum number of L2 state roots that can ever
+	// be in a batch.
+	MaxStateBatchCount uint64
+
+	// MaxBatchSubmissionTime is the maximum amount of time that we will
+	// wait before submitting an under-sized batch.
+	MaxBatchSubmissionTime time.Duration
+
+	// PollInterval is the delay between querying L2 for more transaction
+	// and creating a new batch.
+	PollInterval time.Duration
+
+	// NumConfirmations is the number of confirmations which we will wait after
+	// appending new batches.
+	NumConfirmations uint64
+
+	// ResubmissionTimeout is time we will wait before resubmitting a
+	// transaction.
+	ResubmissionTimeout time.Duration
+
+	// FinalityConfirmations is the number of confirmations that we should wait
+	// before submitting state roots for CTC elements.
+	FinalityConfirmations uint64
+
+	// RunTxBatchSubmitter determines whether or not to run the tx batch
+	// submitter.
+	RunTxBatchSubmitter bool
+
+	// RunStateBatchSubmitter determines whether or not to run the state batch
+	// submitter.
+	RunStateBatchSubmitter bool
+
+	//SafeMinimumEtherBalance is the safe minimum amount of ether the batch
+	//submitter key should hold before it starts to log errors.
+	SafeMinimumEtherBalance uint64
+
+	// ClearPendingTxs is a boolean to clear the pending transactions in the
+	// mempool on startup.
+	ClearPendingTxs bool
+
+	/* Optional Params */
+
+	// LogLevel is the lowest log level that will be output.
+	LogLevel string
+
+	// SentryEnable if true, logs any error messages to sentry. SentryDsn
+	// must also be set if SentryEnable is true.
+	SentryEnable bool
+
+	// SentryDsn is the sentry Data Source Name.
+	SentryDsn string
+
+	// SentryTraceRate the frequency with which Sentry should flush buffered
+	// events.
+	SentryTraceRate time.Duration
+
+	// BlockOffset is the offset between the CTC contract start and the L2 geth
+	// blocks.
+	BlockOffset uint64
+
+	// MaxGasPriceInGwei is the maximum gas price in gwei we will allow in order
+	// to confirm a transaction.
+	MaxGasPriceInGwei uint64
+
+	// GasRetryIncrement is the step size (in gwei) by which we will ratchet the
+	// gas price in order to get a transaction confirmed.
+	GasRetryIncrement uint64
+
+	// SequencerPrivateKey the private key of the wallet used to submit
+	// transactions to the CTC contract.
+	SequencerPrivateKey string
+
+	// PropopserPrivateKey the private key of the wallet used to submit
+	// transaction to the SCC contract.
+	ProposerPrivateKey string
+
+	// Mnemonic is the HD seed used to derive the wallet private keys for both
+	// the sequence and proposer. Must be used in conjunction with
+	// SequencerHDPath and ProposerHDPath.
+	Mnemonic string
+
+	// SequencerHDPath is the derivation path used to obtain the private key for
+	// the sequencer transactions.
+	SequencerHDPath string
+
+	// ProposerHDPath is the derivation path used to obtain the private key for
+	// the proposer transactions.
+	ProposerHDPath string
+
+	// MetricsServerEnable if true, will create a metrics client and log to
+	// Prometheus.
+	MetricsServerEnable bool
+
+	// MetricsHostname is the hostname at which the metrics server is running.
+	MetricsHostname string
+
+	// MetricsPort is the port at which the metrics server is running.
+	MetricsPort uint64
+}
+
+// NewConfig parses the Config from the provided flags or environment variables.
+// This method fails if ValidateConfig deems the configuration to be malformed.
+func NewConfig(ctx *cli.Context) (Config, error) {
+	cfg := Config{
+		/* Required Flags */
+		BuildEnv:                ctx.GlobalString(flags.BuildEnvFlag.Name),
+		EthNetworkName:          ctx.GlobalString(flags.EthNetworkNameFlag.Name),
+		L1EthRpc:                ctx.GlobalString(flags.L1EthRpcFlag.Name),
+		L2EthRpc:                ctx.GlobalString(flags.L2EthRpcFlag.Name),
+		CTCAddress:              ctx.GlobalString(flags.CTCAddressFlag.Name),
+		SCCAddress:              ctx.GlobalString(flags.SCCAddressFlag.Name),
+		MaxL1TxSize:             ctx.GlobalUint64(flags.MaxL1TxSizeFlag.Name),
+		MaxBatchSubmissionTime:  ctx.GlobalDuration(flags.MaxBatchSubmissionTimeFlag.Name),
+		PollInterval:            ctx.GlobalDuration(flags.PollIntervalFlag.Name),
+		NumConfirmations:        ctx.GlobalUint64(flags.NumConfirmationsFlag.Name),
+		ResubmissionTimeout:     ctx.GlobalDuration(flags.ResubmissionTimeoutFlag.Name),
+		FinalityConfirmations:   ctx.GlobalUint64(flags.FinalityConfirmationsFlag.Name),
+		RunTxBatchSubmitter:     ctx.GlobalBool(flags.RunTxBatchSubmitterFlag.Name),
+		RunStateBatchSubmitter:  ctx.GlobalBool(flags.RunStateBatchSubmitterFlag.Name),
+		SafeMinimumEtherBalance: ctx.GlobalUint64(flags.SafeMinimumEtherBalanceFlag.Name),
+		ClearPendingTxs:         ctx.GlobalBool(flags.ClearPendingTxsFlag.Name),
+		/* Optional Flags */
+		SentryEnable:        ctx.GlobalBool(flags.SentryEnableFlag.Name),
+		SentryDsn:           ctx.GlobalString(flags.SentryDsnFlag.Name),
+		SentryTraceRate:     ctx.GlobalDuration(flags.SentryTraceRateFlag.Name),
+		BlockOffset:         ctx.GlobalUint64(flags.BlockOffsetFlag.Name),
+		MaxGasPriceInGwei:   ctx.GlobalUint64(flags.MaxGasPriceInGweiFlag.Name),
+		GasRetryIncrement:   ctx.GlobalUint64(flags.GasRetryIncrementFlag.Name),
+		SequencerPrivateKey: ctx.GlobalString(flags.SequencerPrivateKeyFlag.Name),
+		ProposerPrivateKey:  ctx.GlobalString(flags.ProposerPrivateKeyFlag.Name),
+		Mnemonic:            ctx.GlobalString(flags.MnemonicFlag.Name),
+		SequencerHDPath:     ctx.GlobalString(flags.SequencerHDPathFlag.Name),
+		ProposerHDPath:      ctx.GlobalString(flags.ProposerHDPathFlag.Name),
+		MetricsServerEnable: ctx.GlobalBool(flags.MetricsServerEnableFlag.Name),
+		MetricsHostname:     ctx.GlobalString(flags.MetricsHostnameFlag.Name),
+		MetricsPort:         ctx.GlobalUint64(flags.MetricsPortFlag.Name),
+	}
+
+	err := ValidateConfig(&cfg)
+	if err != nil {
+		return Config{}, err
+	}
+
+	return cfg, nil
+}
+
+// ValidateConfig ensures additional constraints on the parsed configuration to
+// ensure that it is well-formed.
+func ValidateConfig(cfg *Config) error {
+	// Sanity check log level.
+	_, err := log.LvlFromString(cfg.LogLevel)
+	if err != nil {
+		return err
+	}
+
+	// Enforce that either sequencer-private-key or mnemonic + sequencer-hd-path
+	// is enabled, but not both or neither.
+	usingSequencerPrivateKey := cfg.SequencerPrivateKey != ""
+	usingSequencerHDPath := cfg.Mnemonic != "" && cfg.SequencerHDPath != ""
+	if usingSequencerPrivateKey == usingSequencerHDPath {
+		return ErrSequencerPrivKeyOrMnemonic
+	}
+
+	// Enforce that either proposer-private-key or mnemonic + proposer-hd-path
+	// is enabled, but not both or neither.
+	usingProposerPrivateKey := cfg.ProposerPrivateKey != ""
+	usingProposerHDPath := cfg.Mnemonic != "" && cfg.ProposerHDPath != ""
+	if usingProposerPrivateKey == usingProposerHDPath {
+		return ErrProposerPrivKeyOrMnemonic
+	}
+
+	// If mnemonic is used, the sequencer-hd-path and proposer-hd-path must
+	// differ to avoid resuing the same wallet for both.
+	if cfg.Mnemonic != "" && cfg.SequencerHDPath == cfg.ProposerHDPath {
+		return ErrSameSequencerAndProposerHDPath
+	}
+
+	// If private keys are used, ensure the keys are different to avoid resuing
+	// the same wallet for both.
+	if usingSequencerPrivateKey && usingProposerPrivateKey &&
+		cfg.SequencerPrivateKey == cfg.ProposerPrivateKey {
+
+		return ErrSameSequencerAndProposerPrivKey
+	}
+
+	// Ensure the Sentry Data Source Name is set when using Sentry.
+	if cfg.SentryEnable && cfg.SentryDsn == "" {
+		return ErrSentryDSNNotSet
+	}
+
+	return nil
+}

go/batch-submitter/config_test.go

+package batchsubmitter_test
+
+import (
+	"fmt"
+	"testing"
+
+	batchsubmitter "github.com/ethereum-optimism/go/batch-submitter"
+	"github.com/stretchr/testify/require"
+)
+
+var validateConfigTests = []struct {
+	name   string
+	cfg    batchsubmitter.Config
+	expErr error
+}{
+	{
+		name: "bad log level",
+		cfg: batchsubmitter.Config{
+			LogLevel: "unknown",
+		},
+		expErr: fmt.Errorf("unknown level: unknown"),
+	},
+	{
+		name: "sequencer priv key or mnemonic none set",
+		cfg: batchsubmitter.Config{
+			LogLevel: "info",
+
+			SequencerPrivateKey: "",
+			Mnemonic:            "",
+			SequencerHDPath:     "",
+		},
+		expErr: batchsubmitter.ErrSequencerPrivKeyOrMnemonic,
+	},
+	{
+		name: "sequencer priv key or mnemonic both set",
+		cfg: batchsubmitter.Config{
+			LogLevel: "info",
+
+			SequencerPrivateKey: "sequencer-privkey",
+			Mnemonic:            "mnemonic",
+			SequencerHDPath:     "sequencer-path",
+		},
+		expErr: batchsubmitter.ErrSequencerPrivKeyOrMnemonic,
+	},
+	{
+		name: "sequencer priv key or mnemonic only mnemonic set",
+		cfg: batchsubmitter.Config{
+			LogLevel: "info",
+
+			SequencerPrivateKey: "",
+			Mnemonic:            "mnemonic",
+			SequencerHDPath:     "",
+		},
+		expErr: batchsubmitter.ErrSequencerPrivKeyOrMnemonic,
+	},
+	{
+		name: "sequencer priv key or mnemonic only hdpath set",
+		cfg: batchsubmitter.Config{
+			LogLevel: "info",
+
+			SequencerPrivateKey: "",
+			Mnemonic:            "",
+			SequencerHDPath:     "sequencer-path",
+		},
+		expErr: batchsubmitter.ErrSequencerPrivKeyOrMnemonic,
+	},
+	{
+		name: "proposer priv key or mnemonic none set",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+
+			ProposerPrivateKey: "",
+			Mnemonic:           "",
+			ProposerHDPath:     "",
+		},
+		expErr: batchsubmitter.ErrProposerPrivKeyOrMnemonic,
+	},
+	{
+		name: "proposer priv key or mnemonic both set",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+
+			ProposerPrivateKey: "proposer-privkey",
+			Mnemonic:           "mnemonic",
+			ProposerHDPath:     "proposer-path",
+		},
+		expErr: batchsubmitter.ErrProposerPrivKeyOrMnemonic,
+	},
+	{
+		name: "proposer priv key or mnemonic only mnemonic set",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+
+			ProposerPrivateKey: "",
+			Mnemonic:           "mnemonic",
+			ProposerHDPath:     "",
+		},
+		expErr: batchsubmitter.ErrProposerPrivKeyOrMnemonic,
+	},
+	{
+		name: "proposer priv key or mnemonic only hdpath set",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+
+			ProposerPrivateKey: "",
+			Mnemonic:           "",
+			ProposerHDPath:     "proposer-path",
+		},
+		expErr: batchsubmitter.ErrProposerPrivKeyOrMnemonic,
+	},
+	{
+		name: "same sequencer and proposer hd path",
+		cfg: batchsubmitter.Config{
+			LogLevel: "info",
+
+			Mnemonic:        "mnemonic",
+			SequencerHDPath: "path",
+			ProposerHDPath:  "path",
+		},
+		expErr: batchsubmitter.ErrSameSequencerAndProposerHDPath,
+	},
+	{
+		name: "same sequencer and proposer privkey",
+		cfg: batchsubmitter.Config{
+			LogLevel: "info",
+
+			SequencerPrivateKey: "privkey",
+			ProposerPrivateKey:  "privkey",
+		},
+		expErr: batchsubmitter.ErrSameSequencerAndProposerPrivKey,
+	},
+	{
+		name: "sentry-dsn not set when sentry-enable is true",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+			ProposerPrivateKey:  "proposer-privkey",
+
+			SentryEnable: true,
+			SentryDsn:    "",
+		},
+		expErr: batchsubmitter.ErrSentryDSNNotSet,
+	},
+	// Valid configs
+	{
+		name: "valid config with privkeys and no sentry",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+			ProposerPrivateKey:  "proposer-privkey",
+			SentryEnable:        false,
+			SentryDsn:           "",
+		},
+		expErr: nil,
+	},
+	{
+		name: "valid config with mnemonic and no sentry",
+		cfg: batchsubmitter.Config{
+			LogLevel:        "info",
+			Mnemonic:        "mnemonic",
+			SequencerHDPath: "sequencer-path",
+			ProposerHDPath:  "proposer-path",
+			SentryEnable:    false,
+			SentryDsn:       "",
+		},
+		expErr: nil,
+	},
+	{
+		name: "valid config with privkeys and sentry",
+		cfg: batchsubmitter.Config{
+			LogLevel:            "info",
+			SequencerPrivateKey: "sequencer-privkey",
+			ProposerPrivateKey:  "proposer-privkey",
+			SentryEnable:        true,
+			SentryDsn:           "batch-submitter",
+		},
+		expErr: nil,
+	},
+	{
+		name: "valid config with mnemonic and sentry",
+		cfg: batchsubmitter.Config{
+			LogLevel:        "info",
+			Mnemonic:        "mnemonic",
+			SequencerHDPath: "sequencer-path",
+			ProposerHDPath:  "proposer-path",
+			SentryEnable:    true,
+			SentryDsn:       "batch-submitter",
+		},
+		expErr: nil,
+	},
+}
+
+// TestValidateConfig asserts the behavior of ValidateConfig by testing expected
+// error and success configurations.
+func TestValidateConfig(t *testing.T) {
+	for _, test := range validateConfigTests {
+		t.Run(test.name, func(t *testing.T) {
+			err := batchsubmitter.ValidateConfig(&test.cfg)
+			require.Equal(t, err, test.expErr)
+		})
+	}
+}

go/batch-submitter/flags/flags.go

+package flags
+
+import (
+	"time"
+
+	"github.com/urfave/cli"
+)
+
+const envVarPrefix = "BATCH_SUBMITTER_"
+
+func prefixEnvVar(name string) string {
+	return envVarPrefix + name
+}
+
+var (
+	/* Required Flags */
+
+	BuildEnvFlag = cli.StringFlag{
+		Name: "build-env",
+		Usage: "Build environment for which the binary is produced, " +
+			"e.g. production or development",
+		Required: true,
+		EnvVar:   "BUILD_ENV",
+	}
+	EthNetworkNameFlag = cli.StringFlag{
+		Name:     "eth-network-name",
+		Usage:    "Ethereum network name",
+		Required: true,
+		EnvVar:   "ETH_NETWORK_NAME",
+	}
+	L1EthRpcFlag = cli.StringFlag{
+		Name:     "l1-eth-rpc",
+		Usage:    "HTTP provider URL for L1",
+		Required: true,
+		EnvVar:   "L1_ETH_RPC",
+	}
+	L2EthRpcFlag = cli.StringFlag{
+		Name:     "l2-eth-rpc",
+		Usage:    "HTTP provider URL for L2",
+		Required: true,
+		EnvVar:   "L2_ETH_RPC",
+	}
+	CTCAddressFlag = cli.StringFlag{
+		Name:     "ctc-address",
+		Usage:    "Address of the CTC contract",
+		Required: true,
+		EnvVar:   "CTC_ADDRESS",
+	}
+	SCCAddressFlag = cli.StringFlag{
+		Name:     "scc-address",
+		Usage:    "Address of the SCC contract",
+		Required: true,
+		EnvVar:   "SCC_ADDRESS",
+	}
+	MaxL1TxSizeFlag = cli.Uint64Flag{
+		Name: "max-l1-tx-size",
+		Usage: "Maximum size in bytes of any L1 transaction that gets " +
+			"generated by the batch submitter",
+		Required: true,
+		EnvVar:   prefixEnvVar("MAX_L1_TX_SIZE"),
+	}
+	MaxBatchSubmissionTimeFlag = cli.DurationFlag{
+		Name: "max-batch-submission-time",
+		Usage: "Maximum amount of time that we will wait before " +
+			"submitting an under-sized batch",
+		Required: true,
+		EnvVar:   prefixEnvVar("MAX_BATCH_SUBMISSION_TIME"),
+	}
+	PollIntervalFlag = cli.DurationFlag{
+		Name: "poll-interval",
+		Usage: "Delay between querying L2 for more transactions and " +
+			"creating a new batch",
+		Required: true,
+		EnvVar:   prefixEnvVar("POLL_INTERVAL"),
+	}
+	NumConfirmationsFlag = cli.Uint64Flag{
+		Name: "num-confirmations",
+		Usage: "Number of confirmations which we will wait after " +
+			"appending a new batch",
+		Required: true,
+		EnvVar:   prefixEnvVar("NUM_CONFIRMATIONS"),
+	}
+	ResubmissionTimeoutFlag = cli.DurationFlag{
+		Name: "resubmission-timeout",
+		Usage: "Duration we will wait before resubmitting a " +
+			"transaction to L1",
+		Required: true,
+		EnvVar:   prefixEnvVar("RESUBMISSION_TIMEOUT"),
+	}
+	FinalityConfirmationsFlag = cli.Uint64Flag{
+		Name: "finality-confirmations",
+		Usage: "Number of confirmations that we should wait before " +
+			"submitting state roots for CTC elements",
+		Required: true,
+		EnvVar:   prefixEnvVar("FINALITY_CONFIRMATIONS"),
+	}
+	RunTxBatchSubmitterFlag = cli.BoolFlag{
+		Name:     "run-tx-batch-submitter",
+		Usage:    "Determines whether or not to run the tx batch submitter",
+		Required: true,
+		EnvVar:   prefixEnvVar("RUN_TX_BATCH_SUBMITTER"),
+	}
+	RunStateBatchSubmitterFlag = cli.BoolFlag{
+		Name:     "run-state-batch-submitter",
+		Usage:    "Determines whether or not to run the state batch submitter",
+		Required: true,
+		EnvVar:   prefixEnvVar("RUN_STATE_BATCH_SUBMITTER"),
+	}
+	SafeMinimumEtherBalanceFlag = cli.Uint64Flag{
+		Name: "safe-minimum-ether-balance",
+		Usage: "Safe minimum amount of ether the batch submitter key " +
+			"should hold before it starts to log errors",
+		Required: true,
+		EnvVar:   prefixEnvVar("SAFE_MINIMUM_ETHER_BALANCE"),
+	}
+	ClearPendingTxsFlag = cli.BoolFlag{
+		Name: "clear-pending-txs",
+		Usage: "Whether or not to clear pending transaction in the " +
+			"mempool on startup",
+		Required: true,
+		EnvVar:   prefixEnvVar("CLEAR_PENDING_TXS"),
+	}
+
+	/* Optional Flags */
+
+	LogLevelFlag = cli.StringFlag{
+		Name:   "log-level",
+		Usage:  "The lowest log level that will be output",
+		Value:  "info",
+		EnvVar: prefixEnvVar("LOG_LEVEL"),
+	}
+	SentryEnableFlag = cli.BoolFlag{
+		Name:   "sentry-enable",
+		Usage:  "Whether or not to enable Sentry. If true, sentry-dsn must also be set",
+		EnvVar: prefixEnvVar("SENTRY_ENABLE"),
+	}
+	SentryDsnFlag = cli.StringFlag{
+		Name:   "sentry-dsn",
+		Usage:  "Sentry data source name",
+		EnvVar: prefixEnvVar("SENTRY_DSN"),
+	}
+	SentryTraceRateFlag = cli.DurationFlag{
+		Name:   "sentry-trace-rate",
+		Usage:  "Sentry trace rate",
+		Value:  50 * time.Millisecond,
+		EnvVar: prefixEnvVar("SENTRY_TRACE_RATE"),
+	}
+	BlockOffsetFlag = cli.Uint64Flag{
+		Name:   "block-offset",
+		Usage:  "The offset between the CTC contract start and the L2 geth blocks",
+		Value:  1,
+		EnvVar: prefixEnvVar("BLOCK_OFFSET"),
+	}
+	MaxGasPriceInGweiFlag = cli.Uint64Flag{
+		Name:   "max-gas-price-in-gwei",
+		Usage:  "Maximum gas price the batch submitter can use for transactions",
+		Value:  100,
+		EnvVar: prefixEnvVar("MAX_GAS_PRICE_IN_GWEI"),
+	}
+	GasRetryIncrementFlag = cli.Uint64Flag{
+		Name:   "gas-retry-increment",
+		Usage:  "Default step by which to increment gas price bumps",
+		Value:  5,
+		EnvVar: prefixEnvVar("GAS_RETRY_INCREMENT_FLAG"),
+	}
+	SequencerPrivateKeyFlag = cli.StringFlag{
+		Name:   "sequencer-private-key",
+		Usage:  "The private key to use for sending to the sequencer contract",
+		EnvVar: prefixEnvVar("SEQUENCER_PRIVATE_KEY"),
+	}
+	ProposerPrivateKeyFlag = cli.StringFlag{
+		Name:   "proposer-private-key",
+		Usage:  "The private key to use for sending to the proposer contract",
+		EnvVar: prefixEnvVar("PROPOSER_PRIVATE_KEY"),
+	}
+	MnemonicFlag = cli.StringFlag{
+		Name: "mnemonic",
+		Usage: "The mnemonic used to derive the wallets for either the " +
+			"sequencer or the proposer",
+		EnvVar: prefixEnvVar("MNEMONIC"),
+	}
+	SequencerHDPathFlag = cli.StringFlag{
+		Name: "sequencer-hd-path",
+		Usage: "The HD path used to derive the sequencer wallet from the " +
+			"mnemonic. The mnemonic flag must also be set.",
+		EnvVar: prefixEnvVar("SEQUENCER_HD_PATH"),
+	}
+	ProposerHDPathFlag = cli.StringFlag{
+		Name: "proposer-hd-path",
+		Usage: "The HD path used to derive the proposer wallet from the " +
+			"mnemonic. The mnemonic flag must also be set.",
+		EnvVar: prefixEnvVar("PROPOSER_HD_PATH"),
+	}
+	MetricsServerEnableFlag = cli.BoolFlag{
+		Name:   "metrics-server-enable",
+		Usage:  "Whether or not to run the embedded metrics server",
+		EnvVar: prefixEnvVar("METRICS_SERVER_ENABLE"),
+	}
+	MetricsHostnameFlag = cli.StringFlag{
+		Name:   "metrics-hostname",
+		Usage:  "The hostname of the metrics server",
+		Value:  "127.0.0.1",
+		EnvVar: prefixEnvVar("METRICS_HOSTNAME"),
+	}
+	MetricsPortFlag = cli.Uint64Flag{
+		Name:   "metrics-port",
+		Usage:  "The port of the metrics server",
+		Value:  7300,
+		EnvVar: prefixEnvVar("METRICS_PORT"),
+	}
+)
+
+var requiredFlags = []cli.Flag{
+	BuildEnvFlag,
+	EthNetworkNameFlag,
+	L1EthRpcFlag,
+	L2EthRpcFlag,
+	CTCAddressFlag,
+	SCCAddressFlag,
+	MaxL1TxSizeFlag,
+	MaxBatchSubmissionTimeFlag,
+	PollIntervalFlag,
+	NumConfirmationsFlag,
+	ResubmissionTimeoutFlag,
+	FinalityConfirmationsFlag,
+	RunTxBatchSubmitterFlag,
+	RunStateBatchSubmitterFlag,
+	SafeMinimumEtherBalanceFlag,
+	ClearPendingTxsFlag,
+}
+
+var optionalFlags = []cli.Flag{
+	LogLevelFlag,
+	SentryEnableFlag,
+	SentryDsnFlag,
+	SentryTraceRateFlag,
+	BlockOffsetFlag,
+	MaxGasPriceInGweiFlag,
+	GasRetryIncrementFlag,
+	SequencerPrivateKeyFlag,
+	ProposerPrivateKeyFlag,
+	MnemonicFlag,
+	SequencerHDPathFlag,
+	ProposerHDPathFlag,
+	MetricsServerEnableFlag,
+	MetricsHostnameFlag,
+	MetricsPortFlag,
+}
+
+// Flags contains the list of configuration options available to the binary.
+var Flags = append(requiredFlags, optionalFlags...)

go/batch-submitter/flags/flags_test.go

+package flags
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/urfave/cli"
+)
+
+// TestRequiredFlagsSetRequired asserts that all flags deemed required properly
+// have the Required field set to true.
+func TestRequiredFlagsSetRequired(t *testing.T) {
+	for _, flag := range requiredFlags {
+		reqFlag, ok := flag.(cli.RequiredFlag)
+		require.True(t, ok)
+		require.True(t, reqFlag.IsRequired())
+	}
+}
+
+// TestOptionalFlagsDontSetRequired asserts that all flags deemed optional set
+// the Required field to false.
+func TestOptionalFlagsDontSetRequired(t *testing.T) {
+	for _, flag := range optionalFlags {
+		reqFlag, ok := flag.(cli.RequiredFlag)
+		require.True(t, ok)
+		require.False(t, reqFlag.IsRequired())
+	}
+}

go/batch-submitter/go.mod

+module github.com/ethereum-optimism/go/batch-submitter
+
+go 1.16
+
+require (
+	github.com/ethereum/go-ethereum v1.10.8
+	github.com/stretchr/testify v1.7.0
+	github.com/urfave/cli v1.22.5
+)