From 52ff0062d2a69a663cb16c9a18fc8826252f1290 Mon Sep 17 00:00:00 2001 From: Tristan Wilson Date: Wed, 22 Jan 2025 13:15:47 +0100 Subject: [PATCH 1/5] Make auctioneer rpc namespace work on non jwt --- execution/gethexec/node.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/execution/gethexec/node.go b/execution/gethexec/node.go index 7877447481..660c037b71 100644 --- a/execution/gethexec/node.go +++ b/execution/gethexec/node.go @@ -281,7 +281,7 @@ func CreateExecutionNode( Version: "1.0", Service: NewArbTimeboostAuctioneerAPI(txPublisher), Public: false, - Authenticated: true, // Only exposed via JWT Auth to the auctioneer. + Authenticated: false, }) apis = append(apis, rpc.API{ Namespace: "timeboost", From b6651b7c07651e5adc3787f574b8878b6c05bf8a Mon Sep 17 00:00:00 2001 From: Tristan Wilson Date: Fri, 24 Jan 2025 13:40:43 +0100 Subject: [PATCH 2/5] Forward auction resolution txs --- execution/gethexec/sequencer.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/execution/gethexec/sequencer.go b/execution/gethexec/sequencer.go index 765843d602..d45dbb318d 100644 --- a/execution/gethexec/sequencer.go +++ b/execution/gethexec/sequencer.go @@ -514,7 +514,10 @@ func (s *Sequencer) PublishAuctionResolutionTransaction(ctx context.Context, tx return err } if forwarder != nil { - return fmt.Errorf("sequencer is currently not the chosen one, cannot accept auction resolution tx") + err := forwarder.PublishAuctionResolutionTransaction(ctx, tx) + if !errors.Is(err, ErrNoSequencer) { + return err + } } arrivalTime := time.Now() From 8f0213c9b3fe5a554e3d155a695ee9728a986a9f Mon Sep 17 00:00:00 2001 From: Tristan Wilson Date: Tue, 28 Jan 2025 12:40:28 +0100 Subject: [PATCH 3/5] Extra logging for when forwarding fails --- execution/gethexec/forwarder.go | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/execution/gethexec/forwarder.go b/execution/gethexec/forwarder.go index e7a829a431..007c9e3a8c 100644 --- a/execution/gethexec/forwarder.go +++ b/execution/gethexec/forwarder.go @@ -141,10 +141,12 @@ func (f *TxForwarder) PublishTransaction(inctx context.Context, tx *types.Transa } else { err = arbitrum.SendConditionalTransactionRPC(ctx, rpcClient, tx, options) } + if err != nil { + log.Warn("error forwarding transaction to a backup target", "target", f.targets[pos], "err", err) + } if err == nil || !f.tryNewForwarderErrors.MatchString(err.Error()) { return err } - log.Warn("error forwarding transaction to a backup target", "target", f.targets[pos], "err", err) } return errors.New("failed to publish transaction to any of the forwarding targets") } @@ -157,10 +159,12 @@ func (f *TxForwarder) PublishExpressLaneTransaction(inctx context.Context, msg * defer cancelFunc() for pos, rpcClient := range f.rpcClients { err := sendExpressLaneTransactionRPC(ctx, rpcClient, msg) + if err != nil { + log.Warn("error forwarding express lane transaction to a backup target", "target", f.targets[pos], "err", err) + } if err == nil || !f.tryNewForwarderErrors.MatchString(err.Error()) { return err } - log.Warn("error forwarding transaction to a backup target", "target", f.targets[pos], "err", err) } return errors.New("failed to publish transaction to any of the forwarding targets") } @@ -181,10 +185,12 @@ func (f *TxForwarder) PublishAuctionResolutionTransaction(inctx context.Context, defer cancelFunc() for pos, rpcClient := range f.rpcClients { err := sendAuctionResolutionTransactionRPC(ctx, rpcClient, tx) + if err != nil { + log.Warn("error forwarding auction resolution transaction to a backup target", "target", f.targets[pos], "err", err) + } if err == nil || !f.tryNewForwarderErrors.MatchString(err.Error()) { return err } - log.Warn("error forwarding transaction to a backup target", "target", f.targets[pos], "err", err) } return errors.New("failed to publish transaction to any of the forwarding targets") } From 179695b557b87dee236655da8c7de872adc70552 Mon Sep 17 00:00:00 2001 From: Tristan Wilson Date: Tue, 28 Jan 2025 18:54:12 +0100 Subject: [PATCH 4/5] Option to use redis coordinator to find sequencer This PR adds two new options for the autonomous-auctioneer which allow it to discover the active sequencer so that it can send its auction resolution transactions directly to it. If the sequencer is using the redis coordinator to manage which sequencer is active, then the same redis url can be passed as an option to the auctioneer. The new options are: --auctioneer-server.redis-coordinator-url --auctioneer-server.use-redis-coordinator --- timeboost/auctioneer.go | 74 +++++++------ timeboost/sequencer_endpoint_manager.go | 137 ++++++++++++++++++++++++ 2 files changed, 173 insertions(+), 38 deletions(-) create mode 100644 timeboost/sequencer_endpoint_manager.go diff --git a/timeboost/auctioneer.go b/timeboost/auctioneer.go index 5c40505a6b..2766bf68fb 100644 --- a/timeboost/auctioneer.go +++ b/timeboost/auctioneer.go @@ -7,23 +7,18 @@ import ( "context" "fmt" "math/big" - "net/http" - "os" "time" - "github.com/golang-jwt/jwt/v4" "github.com/pkg/errors" "github.com/spf13/pflag" "golang.org/x/crypto/sha3" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" - "github.com/ethereum/go-ethereum/rpc" "github.com/offchainlabs/nitro/cmd/genericconf" "github.com/offchainlabs/nitro/cmd/util" @@ -66,6 +61,8 @@ type AuctioneerServerConfig struct { Wallet genericconf.WalletConfig `koanf:"wallet"` SequencerEndpoint string `koanf:"sequencer-endpoint"` SequencerJWTPath string `koanf:"sequencer-jwt-path"` + UseRedisCoordinator bool `koanf:"use-redis-coordinator"` + RedisCoordinatorURL string `koanf:"redis-coordinator-url"` AuctionContractAddress string `koanf:"auction-contract-address"` DbDirectory string `koanf:"db-directory"` AuctionResolutionWaitTime time.Duration `koanf:"auction-resolution-wait-time"` @@ -91,12 +88,14 @@ var TestAuctioneerServerConfig = AuctioneerServerConfig{ func AuctioneerServerConfigAddOptions(prefix string, f *pflag.FlagSet) { f.Bool(prefix+".enable", DefaultAuctioneerServerConfig.Enable, "enable auctioneer server") - f.String(prefix+".redis-url", DefaultAuctioneerServerConfig.RedisURL, "url of redis server") + f.String(prefix+".redis-url", DefaultAuctioneerServerConfig.RedisURL, "url of redis server to receive bids from bid validators") pubsub.ConsumerConfigAddOptions(prefix+".consumer-config", f) f.Duration(prefix+".stream-timeout", DefaultAuctioneerServerConfig.StreamTimeout, "Timeout on polling for existence of redis streams") genericconf.WalletConfigAddOptions(prefix+".wallet", f, "wallet for auctioneer server") f.String(prefix+".sequencer-endpoint", DefaultAuctioneerServerConfig.SequencerEndpoint, "sequencer RPC endpoint") f.String(prefix+".sequencer-jwt-path", DefaultAuctioneerServerConfig.SequencerJWTPath, "sequencer jwt file path") + f.Bool(prefix+".use-redis-coordinator", DefaultAuctioneerServerConfig.UseRedisCoordinator, "use redis coordinator to find active sequencer") + f.String(prefix+".redis-coordinator-url", DefaultAuctioneerServerConfig.RedisCoordinatorURL, "redis coordinator url for finding active sequencer") f.String(prefix+".auction-contract-address", DefaultAuctioneerServerConfig.AuctionContractAddress, "express lane auction contract address") f.String(prefix+".db-directory", DefaultAuctioneerServerConfig.DbDirectory, "path to database directory for persisting validated bids in a sqlite file") f.Duration(prefix+".auction-resolution-wait-time", DefaultAuctioneerServerConfig.AuctionResolutionWaitTime, "wait time after auction closing before resolving the auction") @@ -110,8 +109,7 @@ type AuctioneerServer struct { consumer *pubsub.Consumer[*JsonValidatedBid, error] txOpts *bind.TransactOpts chainId *big.Int - sequencerRpc *rpc.Client - client *ethclient.Client + endpointManager SequencerEndpointManager auctionContract *express_lane_auctiongen.ExpressLaneAuction auctionContractAddr common.Address bidsReceiver chan *JsonValidatedBid @@ -135,9 +133,6 @@ func NewAuctioneerServer(ctx context.Context, configFetcher AuctioneerServerConf if cfg.DbDirectory == "" { return nil, errors.New("database directory is empty") } - if cfg.SequencerJWTPath == "" { - return nil, errors.New("no sequencer jwt path specified") - } database, err := NewDatabase(cfg.DbDirectory) if err != nil { return nil, err @@ -158,33 +153,24 @@ func NewAuctioneerServer(ctx context.Context, configFetcher AuctioneerServerConf if err != nil { return nil, fmt.Errorf("creating consumer for validation: %w", err) } - sequencerJwtStr, err := os.ReadFile(cfg.SequencerJWTPath) - if err != nil { - return nil, err - } - sequencerJwt, err := hexutil.Decode(string(sequencerJwtStr)) - if err != nil { - return nil, err - } - client, err := rpc.DialOptions(ctx, cfg.SequencerEndpoint, rpc.WithHTTPAuth(func(h http.Header) error { - claims := jwt.MapClaims{ - // Required claim for Ethereum RPC API auth. "iat" stands for issued at - // and it must be a unix timestamp that is +/- 5 seconds from the current - // timestamp at the moment the server verifies this value. - "iat": time.Now().Unix(), - } - token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) - tokenString, err := token.SignedString(sequencerJwt) + + var endpointManager SequencerEndpointManager + if cfg.UseRedisCoordinator { + redisCoordinator, err := redisutil.NewRedisCoordinator(cfg.RedisCoordinatorURL) if err != nil { - return errors.Wrap(err, "could not produce signed JWT token") + return nil, err } - h.Set("Authorization", fmt.Sprintf("Bearer %s", tokenString)) - return nil - })) + endpointManager = NewRedisEndpointManager(redisCoordinator, cfg.SequencerJWTPath) + } else { + endpointManager = NewStaticEndpointManager(cfg.SequencerEndpoint, cfg.SequencerJWTPath) + } + + rpcClient, _, err := endpointManager.GetSequencerRPC(ctx) if err != nil { return nil, err } - sequencerClient := ethclient.NewClient(client) + sequencerClient := ethclient.NewClient(rpcClient) + chainId, err := sequencerClient.ChainID(ctx) if err != nil { return nil, err @@ -210,9 +196,8 @@ func NewAuctioneerServer(ctx context.Context, configFetcher AuctioneerServerConf } return &AuctioneerServer{ txOpts: txOpts, - sequencerRpc: client, + endpointManager: endpointManager, chainId: chainId, - client: sequencerClient, database: database, s3StorageService: s3StorageService, consumer: c, @@ -347,6 +332,19 @@ func (a *AuctioneerServer) resolveAuction(ctx context.Context) error { var err error opts := copyTxOpts(a.txOpts) opts.NoSend = true + + sequencerRpc, newRpc, err := a.endpointManager.GetSequencerRPC(ctx) + if err != nil { + return fmt.Errorf("failed to get sequencer RPC: %w", err) + } + + if newRpc { + a.auctionContract, err = express_lane_auctiongen.NewExpressLaneAuction(a.auctionContractAddr, ethclient.NewClient(sequencerRpc)) + if err != nil { + return fmt.Errorf("failed to recreate ExpressLaneAuction conctract bindings with new sequencer endpoint: %w", err) + } + } + switch { case first != nil && second != nil: // Both bids are present tx, err = a.auctionContract.ResolveMultiBidAuction( @@ -391,13 +389,13 @@ func (a *AuctioneerServer) resolveAuction(ctx context.Context) error { retryInterval := 1 * time.Second if err := retryUntil(ctx, func() error { - if err := a.sequencerRpc.CallContext(ctx, nil, "auctioneer_submitAuctionResolutionTransaction", tx); err != nil { - log.Error("Error submitting auction resolution to privileged sequencer endpoint", "error", err) + if err := sequencerRpc.CallContext(ctx, nil, "auctioneer_submitAuctionResolutionTransaction", tx); err != nil { + log.Error("Error submitting auction resolution to sequencer endpoint", "error", err) return err } // Wait for the transaction to be mined - receipt, err := bind.WaitMined(ctx, a.client, tx) + receipt, err := bind.WaitMined(ctx, ethclient.NewClient(sequencerRpc), tx) if err != nil { log.Error("Error waiting for transaction to be mined", "error", err) return err diff --git a/timeboost/sequencer_endpoint_manager.go b/timeboost/sequencer_endpoint_manager.go new file mode 100644 index 0000000000..ac9a63a771 --- /dev/null +++ b/timeboost/sequencer_endpoint_manager.go @@ -0,0 +1,137 @@ +// Copyright 2024-2025, Offchain Labs, Inc. +// For license information, see https://github.com/nitro/blob/master/LICENSE + +package timeboost + +import ( + "context" + "errors" + "fmt" + "net/http" + "os" + "sync" + "time" + + "github.com/golang-jwt/jwt/v4" + + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rpc" + + "github.com/offchainlabs/nitro/util/redisutil" + "github.com/offchainlabs/nitro/util/stopwaiter" +) + +type SequencerEndpointManager interface { + GetSequencerRPC(ctx context.Context) (*rpc.Client, bool, error) +} + +type RedisEndpointManager struct { + stopwaiter.StopWaiterSafe + redisCoordinator *redisutil.RedisCoordinator + jwtPath string + clientMutex sync.Mutex + client *rpc.Client + clientUrl string +} + +func NewRedisEndpointManager(redisCoordinator *redisutil.RedisCoordinator, jwtPath string) SequencerEndpointManager { + return &RedisEndpointManager{ + redisCoordinator: redisCoordinator, + jwtPath: jwtPath, + } +} + +func (m *RedisEndpointManager) GetSequencerRPC(ctx context.Context) (*rpc.Client, bool, error) { + sequencerUrl, err := m.redisCoordinator.CurrentChosenSequencer(ctx) + if err != nil { + return nil, false, fmt.Errorf("failed to get current sequencer: %w", err) + } + if sequencerUrl == "" { + sequencerUrl, err = m.redisCoordinator.RecommendSequencerWantingLockout(ctx) + if err != nil { + return nil, false, fmt.Errorf("failed to get recommended sequencer: %w", err) + } + if sequencerUrl == "" { + return nil, false, errors.New("no sequencer available") + } + } + + m.clientMutex.Lock() + defer m.clientMutex.Unlock() + + if m.client != nil { + // Check if we're still using the correct sequencer + if err == nil && m.clientUrl == sequencerUrl { + return m.client, false, nil + } + // Sequencer changed, close old client + m.client.Close() + m.client = nil + } + + client, err := createRPCClient(ctx, sequencerUrl, m.jwtPath) + if err != nil { + return nil, false, err + } + log.Info("Created sequencer client", "url", sequencerUrl) + + m.client = client + m.clientUrl = sequencerUrl + return client, true, nil +} + +type StaticEndpointManager struct { + endpoint string + jwtPath string + client *rpc.Client +} + +func NewStaticEndpointManager(endpoint string, jwtPath string) SequencerEndpointManager { + return &StaticEndpointManager{ + endpoint: endpoint, + jwtPath: jwtPath, + } +} + +func (m *StaticEndpointManager) GetSequencerRPC(ctx context.Context) (*rpc.Client, bool, error) { + new := false + if m.client == nil { + client, err := createRPCClient(ctx, m.endpoint, m.jwtPath) + if err != nil { + return nil, false, err + } + m.client = client + new = true + } + return m.client, new, nil +} + +func createRPCClient(ctx context.Context, endpoint string, jwtPath string) (*rpc.Client, error) { + if jwtPath == "" { + return rpc.DialContext(ctx, endpoint) + } + + // Create RPC client with JWT auth + sequencerJwtStr, err := os.ReadFile(jwtPath) + if err != nil { + return nil, err + } + sequencerJwt, err := hexutil.Decode(string(sequencerJwtStr)) + if err != nil { + return nil, err + } + + return rpc.DialOptions(ctx, endpoint, rpc.WithHTTPAuth(func(h http.Header) error { + claims := jwt.MapClaims{ + "iat": time.Now().Unix(), + } + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + tokenString, err := token.SignedString(sequencerJwt) + if err != nil { + return fmt.Errorf("could not produce signed JWT token: %w", err) + } + h.Set("Authorization", fmt.Sprintf("Bearer %s", tokenString)) + return nil + })) +} From f1e2d77289ba7c383d36a3350036ddc289261a3f Mon Sep 17 00:00:00 2001 From: Tristan Wilson Date: Wed, 29 Jan 2025 16:09:54 +0100 Subject: [PATCH 5/5] Take out JWT from timeboost system tests --- system_tests/timeboost_test.go | 31 ++++++++----------------------- 1 file changed, 8 insertions(+), 23 deletions(-) diff --git a/system_tests/timeboost_test.go b/system_tests/timeboost_test.go index 2a72277a12..ee01e2f0ce 100644 --- a/system_tests/timeboost_test.go +++ b/system_tests/timeboost_test.go @@ -10,7 +10,6 @@ import ( "math/big" "net" "os" - "path/filepath" "strings" "sync" "testing" @@ -72,9 +71,8 @@ func testTxsHandlingDuringSequencerSwap(t *testing.T, dueToCrash bool) { t.Cleanup(func() { require.NoError(t, os.RemoveAll(tmpDir)) }) - jwtSecretPath := filepath.Join(tmpDir, "sequencer.jwt") - auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, forwarder, cleanupForwarder := setupExpressLaneAuction(t, tmpDir, ctx, jwtSecretPath, withForwardingSeq) + auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, forwarder, cleanupForwarder := setupExpressLaneAuction(t, tmpDir, ctx, withForwardingSeq) seqB, seqClientB, seqInfo := builderSeq.L2.ConsensusNode, builderSeq.L2.Client, builderSeq.L2Info seqA := forwarder.ConsensusNode if !dueToCrash { @@ -206,9 +204,8 @@ func TestForwardingExpressLaneTxs(t *testing.T) { t.Cleanup(func() { require.NoError(t, os.RemoveAll(tmpDir)) }) - jwtSecretPath := filepath.Join(tmpDir, "sequencer.jwt") - auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, forwarder, cleanupForwarder := setupExpressLaneAuction(t, tmpDir, ctx, jwtSecretPath, withForwardingSeq) + auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, forwarder, cleanupForwarder := setupExpressLaneAuction(t, tmpDir, ctx, withForwardingSeq) seqClient, seqInfo := builderSeq.L2.Client, builderSeq.L2Info defer cleanupSeq() defer cleanupForwarder() @@ -252,9 +249,8 @@ func TestExpressLaneTransactionHandlingComplex(t *testing.T) { t.Cleanup(func() { require.NoError(t, os.RemoveAll(tmpDir)) }) - jwtSecretPath := filepath.Join(tmpDir, "sequencer.jwt") - auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, _, _ := setupExpressLaneAuction(t, tmpDir, ctx, jwtSecretPath, 0) + auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, _, _ := setupExpressLaneAuction(t, tmpDir, ctx, 0) seq, seqClient, seqInfo := builderSeq.L2.ConsensusNode, builderSeq.L2.Client, builderSeq.L2Info defer cleanupSeq() @@ -350,9 +346,8 @@ func TestExpressLaneTransactionHandling(t *testing.T) { t.Cleanup(func() { require.NoError(t, os.RemoveAll(tmpDir)) }) - jwtSecretPath := filepath.Join(tmpDir, "sequencer.jwt") - auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, _, _ := setupExpressLaneAuction(t, tmpDir, ctx, jwtSecretPath, 0) + auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, _, _ := setupExpressLaneAuction(t, tmpDir, ctx, 0) seq, seqClient, seqInfo := builderSeq.L2.ConsensusNode, builderSeq.L2.Client, builderSeq.L2Info defer cleanupSeq() @@ -944,9 +939,8 @@ func TestSequencerFeed_ExpressLaneAuction_ExpressLaneTxsHaveAdvantage(t *testing t.Cleanup(func() { require.NoError(t, os.RemoveAll(tmpDir)) }) - jwtSecretPath := filepath.Join(tmpDir, "sequencer.jwt") - auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, _, _ := setupExpressLaneAuction(t, tmpDir, ctx, jwtSecretPath, 0) + auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, _, _ := setupExpressLaneAuction(t, tmpDir, ctx, 0) seq, seqClient, seqInfo := builderSeq.L2.ConsensusNode, builderSeq.L2.Client, builderSeq.L2Info defer cleanupSeq() @@ -991,8 +985,7 @@ func TestSequencerFeed_ExpressLaneAuction_InnerPayloadNoncesAreRespected_Timeboo t.Cleanup(func() { require.NoError(t, os.RemoveAll(tmpDir)) }) - jwtSecretPath := filepath.Join(tmpDir, "sequencer.jwt") - auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, feedListener, cleanupFeedListener := setupExpressLaneAuction(t, tmpDir, ctx, jwtSecretPath, withFeedListener) + auctionContractAddr, aliceBidderClient, bobBidderClient, roundDuration, builderSeq, cleanupSeq, feedListener, cleanupFeedListener := setupExpressLaneAuction(t, tmpDir, ctx, withFeedListener) seq, seqClient, seqInfo := builderSeq.L2.ConsensusNode, builderSeq.L2.Client, builderSeq.L2Info defer cleanupSeq() defer cleanupFeedListener() @@ -1268,11 +1261,9 @@ func setupExpressLaneAuction( t *testing.T, dbDirPath string, ctx context.Context, - jwtSecretPath string, extraNodeTy extraNodeType, ) (common.Address, *timeboost.BidderClient, *timeboost.BidderClient, time.Duration, *NodeBuilder, func(), *TestClient, func()) { seqPort := getRandomPort(t) - seqAuthPort := getRandomPort(t) forwarderPort := getRandomPort(t) nodeNames := []string{fmt.Sprintf("http://127.0.0.1:%d", seqPort), fmt.Sprintf("http://127.0.0.1:%d", forwarderPort)} @@ -1282,10 +1273,7 @@ func setupExpressLaneAuction( builderSeq := NewNodeBuilder(ctx).DefaultConfig(t, true) builderSeq.l2StackConfig.HTTPHost = "localhost" builderSeq.l2StackConfig.HTTPPort = seqPort - builderSeq.l2StackConfig.HTTPModules = []string{"eth", "arb", "debug", "timeboost"} - builderSeq.l2StackConfig.AuthPort = seqAuthPort - builderSeq.l2StackConfig.AuthModules = []string{"eth", "arb", "debug", "timeboost", "auctioneer"} - builderSeq.l2StackConfig.JWTSecret = jwtSecretPath + builderSeq.l2StackConfig.HTTPModules = []string{"eth", "arb", "debug", "timeboost", "auctioneer"} builderSeq.nodeConfig.Feed.Output = *newBroadcasterConfigTest() builderSeq.nodeConfig.Dangerous.NoSequencerCoordinator = false builderSeq.nodeConfig.SeqCoordinator.Enable = true @@ -1314,8 +1302,6 @@ func setupExpressLaneAuction( forwarderNodeCfg.SeqCoordinator.MyUrl = nodeNames[1] forwarderNodeCfg.SeqCoordinator.DeleteFinalizedMsgs = false builderSeq.l2StackConfig.HTTPPort = forwarderPort - builderSeq.l2StackConfig.AuthPort = getRandomPort(t) - builderSeq.l2StackConfig.JWTSecret = jwtSecretPath extraNode, cleanupExtraNode = builderSeq.Build2ndNode(t, &SecondNodeParams{nodeConfig: forwarderNodeCfg}) case withFeedListener: tcpAddr, ok := seqNode.BroadcastServer.ListenerAddr().(*net.TCPAddr) @@ -1533,11 +1519,10 @@ func setupExpressLaneAuction( bidValidator.Start(ctx) auctioneerCfg := &timeboost.AuctioneerServerConfig{ - SequencerEndpoint: fmt.Sprintf("http://localhost:%d", seqAuthPort), + SequencerEndpoint: fmt.Sprintf("http://localhost:%d", seqPort), AuctionContractAddress: proxyAddr.Hex(), RedisURL: redisURL, ConsumerConfig: pubsub.TestConsumerConfig, - SequencerJWTPath: jwtSecretPath, DbDirectory: dbDirPath, Wallet: genericconf.WalletConfig{ PrivateKey: fmt.Sprintf("00%x", seqInfo.Accounts["AuctionContract"].PrivateKey.D.Bytes()),