Merge branch 'develop' into refcell/impute/mainnetchains

op-batcher/batcher/batch_submitter.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-batcher/flags"
 	"github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-batcher/rpc"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
@@ -33,6 +34,7 @@ func Main(version string, cliCtx *cli.Context) error {
 	}
 
 	l := oplog.NewLogger(cfg.LogConfig)
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 	m := metrics.NewMetrics("default")
 	l.Info("Initializing Batch Submitter")
 

op-batcher/flags/flags.go

@@ -15,24 +15,24 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 )
 
-const envVarPrefix = "OP_BATCHER"
+const EnvVarPrefix = "OP_BATCHER"
 
 var (
 	// Required flags
 	L1EthRpcFlag = cli.StringFlag{
 		Name:   "l1-eth-rpc",
 		Usage:  "HTTP provider URL for L1",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L1_ETH_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L1_ETH_RPC"),
 	}
 	L2EthRpcFlag = cli.StringFlag{
 		Name:   "l2-eth-rpc",
 		Usage:  "HTTP provider URL for L2 execution engine",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L2_ETH_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L2_ETH_RPC"),
 	}
 	RollupRpcFlag = cli.StringFlag{
 		Name:   "rollup-rpc",
 		Usage:  "HTTP provider URL for Rollup node",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "ROLLUP_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "ROLLUP_RPC"),
 	}
 	// Optional flags
 	SubSafetyMarginFlag = cli.Uint64Flag{
@@ -41,54 +41,54 @@ var (
 			"from a channel's timeout and sequencing window, to guarantee safe inclusion " +
 			"of a channel on L1.",
 		Value:  10,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "SUB_SAFETY_MARGIN"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "SUB_SAFETY_MARGIN"),
 	}
 	PollIntervalFlag = cli.DurationFlag{
 		Name:   "poll-interval",
 		Usage:  "How frequently to poll L2 for new blocks",
 		Value:  6 * time.Second,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "POLL_INTERVAL"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "POLL_INTERVAL"),
 	}
 	MaxPendingTransactionsFlag = cli.Uint64Flag{
 		Name:   "max-pending-tx",
 		Usage:  "The maximum number of pending transactions. 0 for no limit.",
 		Value:  1,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "MAX_PENDING_TX"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "MAX_PENDING_TX"),
 	}
 	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"),
+		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.",
 		Value:  120_000,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "MAX_L1_TX_SIZE_BYTES"),
+		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"),
+		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"),
+		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"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "APPROX_COMPR_RATIO"),
 	}
 	StoppedFlag = cli.BoolFlag{
 		Name:   "stopped",
 		Usage:  "Initialize the batcher in a stopped state. The batcher can be started using the admin_startBatcher RPC",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "STOPPED"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "STOPPED"),
 	}
 	// Legacy Flags
 	SequencerHDPathFlag = txmgr.SequencerHDPathFlag
@@ -114,12 +114,12 @@ var optionalFlags = []cli.Flag{
 }
 
 func init() {
-	optionalFlags = append(optionalFlags, oprpc.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oppprof.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, rpc.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, txmgr.CLIFlags(envVarPrefix)...)
+	optionalFlags = append(optionalFlags, oprpc.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, rpc.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, txmgr.CLIFlags(EnvVarPrefix)...)
 
 	Flags = append(requiredFlags, optionalFlags...)
 }

op-challenger/config/config.go

@@ -137,6 +137,9 @@ func NewConfig(
 
 // NewConfigFromCLI parses the Config from the provided flags or environment variables.
 func NewConfigFromCLI(ctx *cli.Context) (*Config, error) {
+	if err := flags.CheckRequired(ctx); err != nil {
+		return nil, err
+	}
 	l1EthRpc := ctx.GlobalString(flags.L1EthRpcFlag.Name)
 	if l1EthRpc == "" {
 		return nil, ErrMissingL1EthRPC

op-challenger/flags/flags_test.go

+package flags
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/urfave/cli"
+)
+
+// TestUniqueFlags asserts that all flag names are unique, to avoid accidental conflicts between the many flags.
+func TestUniqueFlags(t *testing.T) {
+	seenCLI := make(map[string]struct{})
+	for _, flag := range Flags {
+		name := flag.GetName()
+		if _, ok := seenCLI[name]; ok {
+			t.Errorf("duplicate flag %s", name)
+			continue
+		}
+		seenCLI[name] = struct{}{}
+	}
+}
+
+// TestUniqueEnvVars asserts that all flag env vars are unique, to avoid accidental conflicts between the many flags.
+func TestUniqueEnvVars(t *testing.T) {
+	seenCLI := make(map[string]struct{})
+	for _, flag := range Flags {
+		envVar := envVarForFlag(flag)
+		if _, ok := seenCLI[envVar]; envVar != "" && ok {
+			t.Errorf("duplicate flag env var %s", envVar)
+			continue
+		}
+		seenCLI[envVar] = struct{}{}
+	}
+}
+
+func TestCorrectEnvVarPrefix(t *testing.T) {
+	for _, flag := range Flags {
+		envVar := envVarForFlag(flag)
+		if envVar == "" {
+			t.Errorf("Failed to find EnvVar for flag %v", flag.GetName())
+		}
+		if envVar[:len("OP_CHALLENGER_")] != "OP_CHALLENGER_" {
+			t.Errorf("Flag %v env var (%v) does not start with OP_CHALLENGER_", flag.GetName(), envVar)
+		}
+		if strings.Contains(envVar, "__") {
+			t.Errorf("Flag %v env var (%v) has duplicate underscores", flag.GetName(), envVar)
+		}
+	}
+}
+
+func envVarForFlag(flag cli.Flag) string {
+	values := reflect.ValueOf(flag)
+	envVarValue := values.FieldByName("EnvVar")
+	if envVarValue == (reflect.Value{}) {
+		return ""
+	}
+	return envVarValue.String()
+}

op-node/cmd/main.go

@@ -23,6 +23,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/node"
 	"github.com/ethereum-optimism/optimism/op-node/version"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 )
@@ -88,6 +89,7 @@ func RollupNodeMain(ctx *cli.Context) error {
 		return err
 	}
 	log := oplog.NewLogger(logCfg)
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, log)
 	m := metrics.NewMetrics("default")
 
 	cfg, err := opnode.NewConfig(ctx, log)

op-node/flags/flags.go

@@ -14,10 +14,10 @@ import (
 
 // Flags
 
-const envVarPrefix = "OP_NODE"
+const EnvVarPrefix = "OP_NODE"
 
 func prefixEnvVar(name string) string {
-	return envVarPrefix + "_" + name
+	return EnvVarPrefix + "_" + name
 }
 
 var (
@@ -251,7 +251,7 @@ var Flags []cli.Flag
 
 func init() {
 	optionalFlags = append(optionalFlags, p2pFlags...)
-	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
+	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(requiredFlags, optionalFlags...)
 }
 

op-program/host/flags/flags.go

@@ -13,69 +13,69 @@ import (
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 )
 
-const envVarPrefix = "OP_PROGRAM"
+const EnvVarPrefix = "OP_PROGRAM"
 
 var (
 	RollupConfig = cli.StringFlag{
 		Name:   "rollup.config",
 		Usage:  "Rollup chain parameters",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "ROLLUP_CONFIG"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "ROLLUP_CONFIG"),
 	}
 	Network = cli.StringFlag{
 		Name:   "network",
 		Usage:  fmt.Sprintf("Predefined network selection. Available networks: %s", strings.Join(chaincfg.AvailableNetworks(), ", ")),
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "NETWORK"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "NETWORK"),
 	}
 	DataDir = cli.StringFlag{
 		Name:   "datadir",
 		Usage:  "Directory to use for preimage data storage. Default uses in-memory storage",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "DATADIR"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "DATADIR"),
 	}
 	L2NodeAddr = cli.StringFlag{
 		Name:   "l2",
 		Usage:  "Address of L2 JSON-RPC endpoint to use (eth and debug namespace required)",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_RPC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_RPC"),
 	}
 	L1Head = cli.StringFlag{
 		Name:   "l1.head",
 		Usage:  "Hash of the L1 head block. Derivation stops after this block is processed.",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_HEAD"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_HEAD"),
 	}
 	L2Head = cli.StringFlag{
 		Name:   "l2.head",
 		Usage:  "Hash of the agreed L2 block to start derivation from",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_HEAD"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_HEAD"),
 	}
 	L2Claim = cli.StringFlag{
 		Name:   "l2.claim",
 		Usage:  "Claimed L2 output root to validate",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_CLAIM"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_CLAIM"),
 	}
 	L2BlockNumber = cli.Uint64Flag{
 		Name:   "l2.blocknumber",
 		Usage:  "Number of the L2 block that the claim is from",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_BLOCK_NUM"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_BLOCK_NUM"),
 	}
 	L2GenesisPath = cli.StringFlag{
 		Name:   "l2.genesis",
 		Usage:  "Path to the op-geth genesis file",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_GENESIS"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_GENESIS"),
 	}
 	L1NodeAddr = cli.StringFlag{
 		Name:   "l1",
 		Usage:  "Address of L1 JSON-RPC endpoint to use (eth namespace required)",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_RPC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_RPC"),
 	}
 	L1TrustRPC = cli.BoolFlag{
 		Name:   "l1.trustrpc",
 		Usage:  "Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_TRUST_RPC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_TRUST_RPC"),
 	}
 	L1RPCProviderKind = cli.GenericFlag{
 		Name: "l1.rpckind",
 		Usage: "The kind of RPC provider, used to inform optimal transactions receipts fetching, and thus reduce costs. Valid options: " +
 			nodeflags.EnumString[sources.RPCProviderKind](sources.RPCProviderKinds),
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_RPC_KIND"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_RPC_KIND"),
 		Value: func() *sources.RPCProviderKind {
 			out := sources.RPCKindBasic
 			return &out
@@ -84,12 +84,12 @@ var (
 	Exec = cli.StringFlag{
 		Name:   "exec",
 		Usage:  "Run the specified client program as a separate process detached from the host. Default is to run the client program in the host process.",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "EXEC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "EXEC"),
 	}
 	Server = cli.BoolFlag{
 		Name:   "server",
 		Usage:  "Run in pre-image server mode without executing any client program.",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "SERVER"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "SERVER"),
 	}
 )
 
@@ -116,7 +116,7 @@ var programFlags = []cli.Flag{
 }
 
 func init() {
-	Flags = append(Flags, oplog.CLIFlags(envVarPrefix)...)
+	Flags = append(Flags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(Flags, requiredFlags...)
 	Flags = append(Flags, programFlags...)
 }

op-program/host/host.go

@@ -15,10 +15,12 @@ import (
 	cl "github.com/ethereum-optimism/optimism/op-program/client"
 	"github.com/ethereum-optimism/optimism/op-program/client/driver"
 	"github.com/ethereum-optimism/optimism/op-program/host/config"
+	"github.com/ethereum-optimism/optimism/op-program/host/flags"
 	"github.com/ethereum-optimism/optimism/op-program/host/kvstore"
 	"github.com/ethereum-optimism/optimism/op-program/host/prefetcher"
 	oppio "github.com/ethereum-optimism/optimism/op-program/io"
 	"github.com/ethereum-optimism/optimism/op-program/preimage"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -32,6 +34,7 @@ func Main(logger log.Logger, cfg *config.Config) error {
 	if err := cfg.Check(); err != nil {
 		return fmt.Errorf("invalid config: %w", err)
 	}
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, logger)
 	cfg.Rollup.LogDescription(logger, chaincfg.L2ChainIDToNetworkName)
 
 	ctx := context.Background()

op-proposer/flags/flags.go

@@ -14,24 +14,24 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 )
 
-const envVarPrefix = "OP_PROPOSER"
+const EnvVarPrefix = "OP_PROPOSER"
 
 var (
 	// Required Flags
 	L1EthRpcFlag = cli.StringFlag{
 		Name:   "l1-eth-rpc",
 		Usage:  "HTTP provider URL for L1",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L1_ETH_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L1_ETH_RPC"),
 	}
 	RollupRpcFlag = cli.StringFlag{
 		Name:   "rollup-rpc",
 		Usage:  "HTTP provider URL for the rollup node",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "ROLLUP_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "ROLLUP_RPC"),
 	}
 	L2OOAddressFlag = cli.StringFlag{
 		Name:   "l2oo-address",
 		Usage:  "Address of the L2OutputOracle contract",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L2OO_ADDRESS"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L2OO_ADDRESS"),
 	}
 
 	// Optional flags
@@ -39,12 +39,12 @@ var (
 		Name:   "poll-interval",
 		Usage:  "How frequently to poll L2 for new blocks",
 		Value:  6 * time.Second,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "POLL_INTERVAL"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "POLL_INTERVAL"),
 	}
 	AllowNonFinalizedFlag = cli.BoolFlag{
 		Name:   "allow-non-finalized",
 		Usage:  "Allow the proposer to submit proposals for L2 blocks derived from non-finalized L1 blocks.",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "ALLOW_NON_FINALIZED"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "ALLOW_NON_FINALIZED"),
 	}
 	// Legacy Flags
 	L2OutputHDPathFlag = txmgr.L2OutputHDPathFlag
@@ -63,11 +63,11 @@ var optionalFlags = []cli.Flag{
 }
 
 func init() {
-	optionalFlags = append(optionalFlags, oprpc.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oppprof.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, txmgr.CLIFlags(envVarPrefix)...)
+	optionalFlags = append(optionalFlags, oprpc.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, txmgr.CLIFlags(EnvVarPrefix)...)
 
 	Flags = append(requiredFlags, optionalFlags...)
 }

op-proposer/proposer/l2_output_submitter.go

@@ -46,6 +46,7 @@ func Main(version string, cliCtx *cli.Context) error {
 	}
 
 	l := oplog.NewLogger(cfg.LogConfig)
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 	m := metrics.NewMetrics("default")
 	l.Info("Initializing L2 Output Submitter")
 

op-service/util.go

@@ -6,16 +6,59 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
+	"reflect"
+	"strings"
 	"syscall"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/urfave/cli"
 )
 
 func PrefixEnvVar(prefix, suffix string) string {
 	return prefix + "_" + suffix
 }
 
+// ValidateEnvVars logs all env vars that are found where the env var is
+// prefixed with the supplied prefix (like OP_BATCHER) but there is no
+// actual env var with that name.
+// It helps validate that the supplied env vars are in fact valid.
+func ValidateEnvVars(prefix string, flags []cli.Flag, log log.Logger) {
+	for _, envVar := range validateEnvVars(prefix, os.Environ(), cliFlagsToEnvVars(flags)) {
+		log.Warn("Unknown env var", "prefix", prefix, "env_var", envVar)
+	}
+}
+
+func cliFlagsToEnvVars(flags []cli.Flag) map[string]struct{} {
+	definedEnvVars := make(map[string]struct{})
+	for _, flag := range flags {
+		envVarField := reflect.ValueOf(flag).FieldByName("EnvVar")
+		if envVarField.IsValid() {
+			definedEnvVars[envVarField.String()] = struct{}{}
+		}
+	}
+	return definedEnvVars
+}
+
+// validateEnvVars returns a list of the unknown environment variables that match the prefix.
+func validateEnvVars(prefix string, providedEnvVars []string, definedEnvVars map[string]struct{}) []string {
+	var out []string
+	for _, envVar := range providedEnvVars {
+		parts := strings.Split(envVar, "=")
+		if len(parts) == 0 {
+			continue
+		}
+		key := parts[0]
+		if strings.HasPrefix(key, prefix) {
+			if _, ok := definedEnvVars[key]; !ok {
+				out = append(out, envVar)
+			}
+		}
+	}
+	return out
+}
+
 // ParseAddress parses an ETH address from a hex string. This method will fail if
 // the address is not a valid hexadecimal address.
 func ParseAddress(address string) (common.Address, error) {

op-service/util_test.go

+package op_service
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/urfave/cli"
+)
+
+func TestCLIFlagsToEnvVars(t *testing.T) {
+	flags := []cli.Flag{
+		cli.StringFlag{
+			Name:   "test",
+			EnvVar: "OP_NODE_TEST_VAR",
+		},
+		cli.IntFlag{
+			Name: "no env var",
+		},
+	}
+	res := cliFlagsToEnvVars(flags)
+	require.Contains(t, res, "OP_NODE_TEST_VAR")
+}
+
+func TestValidateEnvVars(t *testing.T) {
+	provided := []string{"OP_BATCHER_CONFIG=true", "OP_BATCHER_FAKE=false", "LD_PRELOAD=/lib/fake.so"}
+	defined := map[string]struct{}{
+		"OP_BATCHER_CONFIG": {},
+		"OP_BATCHER_OTHER":  {},
+	}
+	invalids := validateEnvVars("OP_BATCHER", provided, defined)
+	require.ElementsMatch(t, invalids, []string{"OP_BATCHER_FAKE=false"})
+}