txmgr: Initialize signer and more in the tx manager proper

op-batcher/batcher/batch_submitter.go

@@ -73,7 +73,7 @@ func Main(version string, cliCtx *cli.Context) error {
 				l.Error("error starting metrics server", err)
 			}
 		}()
-		m.StartBalanceMetrics(ctx, l, batchSubmitter.L1Client, batchSubmitter.From)
+		m.StartBalanceMetrics(ctx, l, batchSubmitter.L1Client, batchSubmitter.TxManager.From())
 	}
 
 	rpcCfg := cfg.RPCConfig

op-batcher/batcher/config.go

@@ -3,7 +3,6 @@ package batcher
 import (
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli"
@@ -17,7 +16,6 @@ import (
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
-	opsigner "github.com/ethereum-optimism/optimism/op-signer/client"
 )
 
 type Config struct {
@@ -26,11 +24,9 @@ type Config struct {
 	L1Client   *ethclient.Client
 	L2Client   *ethclient.Client
 	RollupNode *sources.RollupClient
+	TxManager  txmgr.TxManager
 
 	PollInterval time.Duration
-	From         common.Address
-
-	TxManagerConfig txmgr.Config
 
 	// RollupConfig is queried at startup
 	Rollup *rollup.Config
@@ -51,8 +47,6 @@ func (c *Config) Check() error {
 }
 
 type CLIConfig struct {
-	/* Required Params */
-
 	// L1EthRpc is the HTTP provider URL for L1.
 	L1EthRpc string
 
@@ -81,43 +75,6 @@ type CLIConfig struct {
 	// and creating a new batch.
 	PollInterval time.Duration
 
-	// NumConfirmations is the number of confirmations which we will wait after
-	// appending new batches.
-	NumConfirmations uint64
-
-	// SafeAbortNonceTooLowCount is the number of ErrNonceTooLowObservations
-	// required to give up on a tx at a particular nonce without receiving
-	// confirmation.
-	SafeAbortNonceTooLowCount uint64
-
-	// ResubmissionTimeout is time we will wait before resubmitting a
-	// transaction.
-	ResubmissionTimeout time.Duration
-
-	// 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
-	// batched submission of sequencer transactions.
-	SequencerHDPath string
-
-	// PrivateKey is the private key used to submit sequencer transactions.
-	PrivateKey string
-
-	RPCConfig rpc.CLIConfig
-
-	/* Optional Params */
-
-	// TxManagerTimeout is the max amount of time to wait for the [txmgr].
-	// This will default to: 10 * time.Minute.
-	TxManagerTimeout time.Duration
-
-	// OfflineGasEstimation specifies whether the batcher should calculate
-	// gas estimations offline using the [core.IntrinsicGas] function.
-	OfflineGasEstimation bool
-
 	// MaxL1TxSize is the maximum size of a batch tx submitted to L1.
 	MaxL1TxSize uint64
 
@@ -133,14 +90,11 @@ type CLIConfig struct {
 
 	Stopped bool
 
-	LogConfig oplog.CLIConfig
-
+	TxMgrConfig   txmgr.CLIConfig
+	RPCConfig     rpc.CLIConfig
+	LogConfig     oplog.CLIConfig
 	MetricsConfig opmetrics.CLIConfig
-
-	PprofConfig oppprof.CLIConfig
-
-	// SignerConfig contains the client config for op-signer service
-	SignerConfig opsigner.CLIConfig
+	PprofConfig   oppprof.CLIConfig
 }
 
 func (c CLIConfig) Check() error {
@@ -156,7 +110,7 @@ func (c CLIConfig) Check() error {
 	if err := c.PprofConfig.Check(); err != nil {
 		return err
 	}
-	if err := c.SignerConfig.Check(); err != nil {
+	if err := c.TxMgrConfig.Check(); err != nil {
 		return err
 	}
 	return nil
@@ -166,31 +120,23 @@ func (c CLIConfig) Check() error {
 func NewConfig(ctx *cli.Context) CLIConfig {
 	return CLIConfig{
 		/* Required Flags */
-		L1EthRpc:                  ctx.GlobalString(flags.L1EthRpcFlag.Name),
-		L2EthRpc:                  ctx.GlobalString(flags.L2EthRpcFlag.Name),
-		RollupRpc:                 ctx.GlobalString(flags.RollupRpcFlag.Name),
-		SubSafetyMargin:           ctx.GlobalUint64(flags.SubSafetyMarginFlag.Name),
-		PollInterval:              ctx.GlobalDuration(flags.PollIntervalFlag.Name),
-		NumConfirmations:          ctx.GlobalUint64(flags.NumConfirmationsFlag.Name),
-		SafeAbortNonceTooLowCount: ctx.GlobalUint64(flags.SafeAbortNonceTooLowCountFlag.Name),
-		ResubmissionTimeout:       ctx.GlobalDuration(flags.ResubmissionTimeoutFlag.Name),
+		L1EthRpc:        ctx.GlobalString(flags.L1EthRpcFlag.Name),
+		L2EthRpc:        ctx.GlobalString(flags.L2EthRpcFlag.Name),
+		RollupRpc:       ctx.GlobalString(flags.RollupRpcFlag.Name),
+		SubSafetyMargin: ctx.GlobalUint64(flags.SubSafetyMarginFlag.Name),
+		PollInterval:    ctx.GlobalDuration(flags.PollIntervalFlag.Name),
 
 		/* Optional Flags */
-		OfflineGasEstimation: ctx.GlobalBool(flags.OfflineGasEstimationFlag.Name),
-		TxManagerTimeout:     ctx.GlobalDuration(flags.TxManagerTimeoutFlag.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),
-		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),
+		TxMgrConfig:        txmgr.ReadCLIConfig(ctx),
+		RPCConfig:          rpc.ReadCLIConfig(ctx),
+		LogConfig:          oplog.ReadCLIConfig(ctx),
+		MetricsConfig:      opmetrics.ReadCLIConfig(ctx),
+		PprofConfig:        oppprof.ReadCLIConfig(ctx),
 	}
 }

op-batcher/batcher/driver.go

@@ -13,7 +13,6 @@ import (
 	"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"
-	opcrypto "github.com/ethereum-optimism/optimism/op-service/crypto"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -48,11 +47,6 @@ type BatchSubmitter struct {
 func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metricer) (*BatchSubmitter, error) {
 	ctx := context.Background()
 
-	signer, fromAddress, err := opcrypto.SignerFactoryFromConfig(l, cfg.PrivateKey, cfg.Mnemonic, cfg.SequencerHDPath, cfg.SignerConfig)
-	if err != nil {
-		return nil, err
-	}
-
 	// Connect to L1 and L2 providers. Perform these last since they are the
 	// most expensive.
 	l1Client, err := dialEthClientWithTimeout(ctx, cfg.L1EthRpc)
@@ -75,24 +69,19 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 		return nil, fmt.Errorf("querying rollup config: %w", err)
 	}
 
-	txManagerConfig := txmgr.Config{
-		ResubmissionTimeout:       cfg.ResubmissionTimeout,
-		ReceiptQueryInterval:      time.Second,
-		NumConfirmations:          cfg.NumConfirmations,
-		SafeAbortNonceTooLowCount: cfg.SafeAbortNonceTooLowCount,
-		From:                      fromAddress,
-		ChainID:                   rcfg.L1ChainID,
-		Signer:                    signer(rcfg.L1ChainID),
+	txManagerConfig, err := txmgr.NewConfig(cfg.TxMgrConfig, l)
+	if err != nil {
+		return nil, err
 	}
+	txManager := txmgr.NewSimpleTxManager("batcher", l, txManagerConfig)
 
 	batcherCfg := Config{
-		L1Client:        l1Client,
-		L2Client:        l2Client,
-		RollupNode:      rollupClient,
-		PollInterval:    cfg.PollInterval,
-		TxManagerConfig: txManagerConfig,
-		From:            fromAddress,
-		Rollup:          rcfg,
+		L1Client:     l1Client,
+		L2Client:     l2Client,
+		RollupNode:   rollupClient,
+		PollInterval: cfg.PollInterval,
+		TxManager:    txManager,
+		Rollup:       rcfg,
 		Channel: ChannelConfig{
 			SeqWindowSize:      rcfg.SeqWindowSize,
 			ChannelTimeout:     rcfg.ChannelTimeout,
@@ -116,19 +105,19 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 // NewBatchSubmitter initializes the BatchSubmitter, gathering any resources
 // that will be needed during operation.
 func NewBatchSubmitter(ctx context.Context, cfg Config, l log.Logger, m metrics.Metricer) (*BatchSubmitter, error) {
-	balance, err := cfg.L1Client.BalanceAt(ctx, cfg.From, nil)
+	balance, err := cfg.L1Client.BalanceAt(ctx, cfg.TxManager.From(), nil)
 	if err != nil {
 		return nil, err
 	}
 
 	cfg.log = l
-	cfg.log.Info("creating batch submitter", "submitter_addr", cfg.From, "submitter_bal", balance)
+	cfg.log.Info("creating batch submitter", "submitter_addr", cfg.TxManager.From(), "submitter_bal", balance)
 
 	cfg.metr = m
 
 	return &BatchSubmitter{
 		Config: cfg,
-		txMgr:  txmgr.NewSimpleTxManager("batcher", l, cfg.TxManagerConfig, cfg.L1Client),
+		txMgr:  cfg.TxManager,
 		state:  NewChannelManager(l, m, cfg.Channel),
 	}, nil
 
@@ -377,7 +366,7 @@ func (l *BatchSubmitter) sendTransaction(ctx context.Context, data []byte) (*typ
 	if receipt, err := l.txMgr.Send(ctx, txmgr.TxCandidate{
 		To:       l.Rollup.BatchInboxAddress,
 		TxData:   data,
-		From:     l.From,
+		From:     l.txMgr.From(),
 		GasLimit: intrinsicGas,
 	}); err != nil {
 		l.log.Warn("unable to publish tx", "err", err, "data_size", len(data))