check the auction is over when submitting a bundle

auction/auction.go

@@ -67,6 +67,12 @@ func NewAuction(duration time.Duration, maxSolutions uint64, userOp *operation.U
 	return auction
 }
 
+func (a *Auction) isOpen() bool {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.open
+}
+
 func (a *Auction) close() {
 	a.mu.Lock()
 	defer a.mu.Unlock()

auction/manager.go

@@ -76,7 +76,7 @@ func (am *Manager) auctionsCleaner() {
 	for range time.Tick(10 * time.Minute) {
 		am.mu.Lock()
 		for userOpHash, auction := range am.auctions {
-			if !auction.open && time.Since(auction.createdAt) > time.Hour {
+			if !auction.isOpen() && time.Since(auction.createdAt) > time.Hour {
 				delete(am.auctions, userOpHash)
 			}
 		}
@@ -160,6 +160,13 @@ func (am *Manager) GetSolverOperations(userOpHash common.Hash, completionChan ch
 	return auction.getSolverOps(completionChan)
 }
 
+func (am *Manager) IsAuctionOngoing(userOpHash common.Hash) bool {
+	am.mu.RLock()
+	defer am.mu.RUnlock()
+	auction, ok := am.auctions[userOpHash]
+	return ok && auction.isOpen()
+}
+
 func (am *Manager) getAuction(userOpHash common.Hash) *Auction {
 	am.mu.RLock()
 	defer am.mu.RUnlock()

bundle/manager.go

@@ -5,6 +5,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/FastLane-Labs/atlas-operations-relay/auction"
 	"github.com/FastLane-Labs/atlas-operations-relay/config"
 	"github.com/FastLane-Labs/atlas-operations-relay/contract"
 	"github.com/FastLane-Labs/atlas-operations-relay/contract/dAppControl"
@@ -24,6 +25,7 @@ var (
 )
 
 type getDAppConfigFn func(common.Address, *operation.UserOperation) (*dAppControl.DAppConfig, *relayerror.Error)
+type isAuctionOngoingFn func(common.Hash) bool
 
 type Manager struct {
 	ethClient *ethclient.Client
@@ -34,18 +36,20 @@ type Manager struct {
 
 	atlasDomainSeparator common.Hash
 
-	getDAppConfig getDAppConfigFn
+	getDAppConfig    getDAppConfigFn
+	isAuctionOngoing isAuctionOngoingFn
 
 	mu sync.RWMutex
 }
 
-func NewManager(ethClient *ethclient.Client, config *config.Config, atlasDomainSeparator common.Hash, getDAppConfig getDAppConfigFn) *Manager {
+func NewManager(ethClient *ethclient.Client, config *config.Config, atlasDomainSeparator common.Hash, getDAppConfig getDAppConfigFn, isAuctionOngoing isAuctionOngoingFn) *Manager {
 	bm := &Manager{
 		ethClient:            ethClient,
 		config:               config,
 		bundles:              make(map[common.Hash]*Bundle),
 		atlasDomainSeparator: atlasDomainSeparator,
 		getDAppConfig:        getDAppConfig,
+		isAuctionOngoing:     isAuctionOngoing,
 	}
 
 	go bm.bundlesCleaner()
@@ -77,6 +81,11 @@ func (bm *Manager) NewBundle(bundleOps *operation.BundleOperations) (common.Hash
 		return common.Hash{}, nil, relayErr
 	}
 
+	if bm.isAuctionOngoing(userOpHash) {
+		log.Info("auction is ongoing", "userOpHash", userOpHash.Hex())
+		return common.Hash{}, nil, auction.ErrAuctionOngoing
+	}
+
 	relayErr = bundleOps.Validate(bm.ethClient, userOpHash, bm.config.Contracts.Atlas, bm.atlasDomainSeparator, bm.config.Relay.Gas.MaxPerUserOperation, bm.config.Relay.Gas.MaxPerDAppOperation, dAppConfig)
 	if relayErr != nil {
 		log.Info("invalid dapp operation", "err", relayErr.Message, "userOpHash", userOpHash.Hex())

core/relay.go

@@ -67,7 +67,7 @@ func NewRelay(ethClient *ethclient.Client, config *config.Config) *Relay {
 	}
 
 	r.auctionManager = auction.NewManager(ethClient, config, atlasDomainSeparator, r.solverGasLimit, r.balanceOfBonded, r.reputationScore, r.getDAppConfig)
-	r.bundleManager = bundle.NewManager(ethClient, config, atlasDomainSeparator, r.getDAppConfig)
+	r.bundleManager = bundle.NewManager(ethClient, config, atlasDomainSeparator, r.getDAppConfig, r.auctionManager.IsAuctionOngoing)
 	r.server = NewServer(NewRouter(NewApi(r)), r.auctionManager.NewSolverOperation, r.auctionManager.GetSolverOperationStatus, r.getDAppSignatories)
 
 	return r