RFQ Relayer: restrict state transitions

core/mapmutex/mapmutex.go

@@ -2,8 +2,9 @@ package mapmutex
 
 import (
 	"fmt"
-	"github.com/LK4d4/trylock"
 	"sync"
+
+	"github.com/LK4d4/trylock"
 )
 
 // untypedMapMutex wraps a map of mutexes.  Each key locks separately.
@@ -13,6 +14,7 @@ import (
 type untypedMapMutex interface {
 	Lock(key interface{}) Unlocker
 	TryLock(key interface{}) (Unlocker, bool)
+	Keys() []interface{}
 }
 
 type untypedMapMutexImpl struct {
@@ -82,6 +84,18 @@ func (m *untypedMapMutexImpl) TryLock(key interface{}) (Unlocker, bool) {
 	return nil, false
 }
 
+// Keys returns all keys in the map.
+func (m *untypedMapMutexImpl) Keys() []interface{} {
+	// note that we don't lock here in case the map is already locked.
+	// the idea is that this function can be used for debugging-
+	// there may be read inconsistencies.
+	keys := make([]interface{}, 0, len(m.ma))
+	for k := range m.ma {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
 // Unlock releases the lock for this entry.
 func (me *mentry) Unlock() {
 	m := me.m

core/mapmutex/mapmutex_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	. "github.com/stretchr/testify/assert"
 	"github.com/synapsecns/sanguine/core/mapmutex"
+	"gotest.tools/assert"
 )
 
 // ExampleMapMutex provides an example implementation of a map mutex.
@@ -52,6 +53,28 @@ func (s MapMutexSuite) TestExampleMapMutex() {
 	NotPanics(s.T(), ExampleStringMapMutex)
 }
 
+func (s MapMutexSuite) TestKeys() {
+	s.T().Run("StringMapMutexKeys", func(t *testing.T) {
+		mapMutex := mapmutex.NewStringMapMutex()
+		mapMutex.Lock("lock1")
+		assert.Equal(t, "lock1", mapMutex.Keys()[0])
+		assert.Equal(t, 1, len(mapMutex.Keys()))
+	})
+	s.T().Run("StringerMapMutexKeys", func(t *testing.T) {
+		mapMutex := mapmutex.NewStringerMapMutex()
+		vitalik := common.HexToAddress("0xab5801a7d398351b8be11c439e05c5b3259aec9b")
+		mapMutex.Lock(vitalik)
+		assert.Equal(t, vitalik.String(), mapMutex.Keys()[0])
+		assert.Equal(t, 1, len(mapMutex.Keys()))
+	})
+	s.T().Run("IntMapMutexKeys", func(t *testing.T) {
+		mapMutex := mapmutex.NewIntMapMutex()
+		mapMutex.Lock(1)
+		assert.Equal(t, 1, mapMutex.Keys()[0])
+		assert.Equal(t, 1, len(mapMutex.Keys()))
+	})
+}
+
 func (s MapMutexSuite) TestMapMutex() {
 	//nolint:gosec
 	r := rand.New(rand.NewSource(42))

core/mapmutex/stringer.go

@@ -1,11 +1,14 @@
 package mapmutex
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // StringerMapMutex is an implementation of mapMutex for the fmt.Stringer conforming types.
 type StringerMapMutex interface {
 	Lock(key fmt.Stringer) Unlocker
 	TryLock(key fmt.Stringer) (Unlocker, bool)
+	Keys() []string
 }
 
 // stringerLockerImpl is the implementation of StringerMapMutex.
@@ -22,6 +25,15 @@
 	return s.mapMux.Lock(key.String())
 }
 
+// Keys returns the keys of the map.
+func (s stringerLockerImpl) Keys() []string {
+	keys := []string{}
+	for _, key := range s.mapMux.Keys() {
+		keys = append(keys, key.(string))
+	}
+	return keys
+}
+
 // NewStringerMapMutex creates an initialized locker that locks on fmt.String.
 func NewStringerMapMutex() StringerMapMutex {
 	return &stringerLockerImpl{
@@ -33,6 +45,7 @@
 type StringMapMutex interface {
 	Lock(key string) Unlocker
 	TryLock(key string) (Unlocker, bool)
+	Keys() []string
 }
 
 // stringMutexImpl locks on a string type.
@@ -57,10 +70,20 @@
 	return s.mapMux.TryLock(key)
 }
 
+// Keys returns the keys of the map.
+func (s stringMutexImpl) Keys() []string {
+	keys := []string{}
+	for _, key := range s.mapMux.Keys() {
+		keys = append(keys, key.(string))
+	}
+	return keys
+}
+
 // IntMapMutex is a map mutex that allows locking on an int.
 type IntMapMutex interface {
 	Lock(key int) Unlocker
 	TryLock(key int) (Unlocker, bool)
+	Keys() []int
 }
 
 // intMapMux locks on an int.
@@ -77,6 +100,15 @@
 	return i.mapMux.Lock(key)
 }
 
+// Keys returns the keys of the map.
+func (i intMapMux) Keys() []int {
+	keys := []int{}
+	for _, key := range i.mapMux.Keys() {
+		keys = append(keys, key.(int))
+	}
+	return keys
+}
+
 // NewIntMapMutex creates a map mutex for locking on an integer.
 func NewIntMapMutex() IntMapMutex {
 	return &intMapMux{

services/rfq/relayer/reldb/base/quote.go

@@ -5,13 +5,17 @@
 	"errors"
 	"fmt"
 
+	"github.com/ipfs/go-log"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
 
+var logger = log.Logger("relayer-db")
+
 // StoreQuoteRequest stores a quote request.
 func (s Store) StoreQuoteRequest(ctx context.Context, request reldb.QuoteRequest) error {
 	rq := FromQuoteRequest(request)
@@ -89,7 +93,19 @@
 }
 
 // UpdateQuoteRequestStatus todo: db test.
-func (s Store) UpdateQuoteRequestStatus(ctx context.Context, id [32]byte, status reldb.QuoteRequestStatus) error {
+func (s Store) UpdateQuoteRequestStatus(ctx context.Context, id [32]byte, status reldb.QuoteRequestStatus, prevStatus *reldb.QuoteRequestStatus) error {
+	if prevStatus == nil {
+		req, err := s.GetQuoteRequestByID(ctx, id)
+		if err != nil {
+			return fmt.Errorf("could not get quote: %w", err)
+		}
+		prevStatus = &req.Status
+	}
+	if !isValidStateTransition(*prevStatus, status) {
+		logger.Warnf("invalid state transition from %s to %s [txid=%s]", *prevStatus, status, hexutil.Encode(id[:]))
+		return nil
+	}
+
 	tx := s.DB().WithContext(ctx).Model(&RequestForQuote{}).
 		Where(fmt.Sprintf("%s = ?", transactionIDFieldName), hexutil.Encode(id[:])).
 		Update(statusFieldName, status)
@@ -120,3 +136,10 @@
 	}
 	return nil
 }
+
+func isValidStateTransition(prevStatus, status reldb.QuoteRequestStatus) bool {
+	if status == reldb.DeadlineExceeded || status == reldb.WillNotProcess {
+		return true
+	}
+	return status > prevStatus
+}

services/rfq/relayer/reldb/db.go

@@ -24,7 +24,7 @@ type Writer interface {
 	// StoreRebalance stores a rebalance.
 	StoreRebalance(ctx context.Context, rebalance Rebalance) error
 	// UpdateQuoteRequestStatus updates the status of a quote request
-	UpdateQuoteRequestStatus(ctx context.Context, id [32]byte, status QuoteRequestStatus) error
+	UpdateQuoteRequestStatus(ctx context.Context, id [32]byte, status QuoteRequestStatus, prevStatus *QuoteRequestStatus) error
 	// UpdateRebalance updates the status of a rebalance action.
 	// If the origin is supplied, it will be used to update the ID for the corresponding rebalance model.
 	UpdateRebalance(ctx context.Context, rebalance Rebalance, updateID bool) error

services/rfq/relayer/service/chainindexer.go

@@ -79,41 +79,41 @@
 			}
 		case *fastbridge.FastBridgeBridgeRelayed:
 			// blocking lock on the txid mutex to ensure state transitions are not overrwitten
-			unlocker := r.relayMtx.Lock(hexutil.Encode(event.TransactionId[:]))
+			unlocker := r.handlerMtx.Lock(hexutil.Encode(event.TransactionId[:]))
 			defer unlocker.Unlock()
 
 			// it wasn't me
 			if event.Relayer != r.signer.Address() {
 				//nolint: wrapcheck
-				return r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.RelayRaceLost)
+				return r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.RelayRaceLost, nil)
 			}
 
 			err = r.handleRelayLog(ctx, event)
 			if err != nil {
 				return fmt.Errorf("could not handle relay: %w", err)
 			}
 		case *fastbridge.FastBridgeBridgeProofProvided:
-			unlocker := r.relayMtx.Lock(hexutil.Encode(event.TransactionId[:]))
+			unlocker := r.handlerMtx.Lock(hexutil.Encode(event.TransactionId[:]))
 			defer unlocker.Unlock()
 
 			// it wasn't me
 			if event.Relayer != r.signer.Address() {
 				//nolint: wrapcheck
-				return r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.RelayRaceLost)
+				return r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.RelayRaceLost, nil)
 			}
 
 			err = r.handleProofProvided(ctx, event)
 			if err != nil {
 				return fmt.Errorf("could not handle proof provided: %w", err)
 			}
 		case *fastbridge.FastBridgeBridgeDepositClaimed:
-			unlocker := r.relayMtx.Lock(hexutil.Encode(event.TransactionId[:]))
+			unlocker := r.handlerMtx.Lock(hexutil.Encode(event.TransactionId[:]))
 			defer unlocker.Unlock()
 
 			// it wasn't me
 			if event.Relayer != r.signer.Address() {
 				//nolint: wrapcheck
-				return r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.RelayRaceLost)
+				return r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.RelayRaceLost, nil)
 			}
 
 			err = r.handleDepositClaimed(ctx, event)
@@ -206,7 +206,7 @@
 }
 
 func (r *Relayer) handleDepositClaimed(ctx context.Context, event *fastbridge.FastBridgeBridgeDepositClaimed) error {
-	err := r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.ClaimCompleted)
+	err := r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.ClaimCompleted, nil)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}

services/rfq/relayer/service/handlers.go

@@ -37,7 +37,7 @@
 		metrics.EndSpanWithErr(span, err)
 	}()
 
-	unlocker, ok := r.relayMtx.TryLock(hexutil.Encode(req.TransactionId[:]))
+	unlocker, ok := r.handlerMtx.TryLock(hexutil.Encode(req.TransactionId[:]))
 	if !ok {
 		span.SetAttributes(attribute.Bool("locked", true))
 		// already processing this request
@@ -142,7 +142,7 @@
 		return fmt.Errorf("could not determine if should process: %w", err)
 	}
 	if !shouldProcess {
-		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.WillNotProcess)
+		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.WillNotProcess, &request.Status)
 		if err != nil {
 			return fmt.Errorf("could not update request status: %w", err)
 		}
@@ -167,7 +167,7 @@
 	if errors.Is(err, inventory.ErrUnsupportedChain) {
 		// don't process request if chain is currently unsupported
 		span.AddEvent("dropping unsupported chain")
-		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.WillNotProcess)
+		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.WillNotProcess, &request.Status)
 		if err != nil {
 			return fmt.Errorf("could not update request status: %w", err)
 		}
@@ -179,7 +179,7 @@
 
 	// check if we have enough inventory to handle the request
 	if committableBalance.Cmp(request.Transaction.DestAmount) < 0 {
-		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.NotEnoughInventory)
+		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.NotEnoughInventory, &request.Status)
 		if err != nil {
 			return fmt.Errorf("could not update request status: %w", err)
 		}
@@ -206,7 +206,7 @@
 	}
 
 	request.Status = reldb.CommittedPending
-	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.CommittedPending)
+	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.CommittedPending, &request.Status)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}
@@ -270,7 +270,7 @@
 	}
 
 	request.Status = reldb.CommittedConfirmed
-	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.CommittedConfirmed)
+	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.CommittedConfirmed, &request.Status)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}
@@ -300,7 +300,7 @@
 	span.AddEvent("relay successfully submitted")
 	span.SetAttributes(attribute.Int("relay_nonce", int(nonce)))
 
-	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.RelayStarted)
+	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.RelayStarted, &request.Status)
 	if err != nil {
 		return fmt.Errorf("could not update quote request status: %w", err)
 	}
@@ -332,7 +332,7 @@
 	}
 
 	// TODO: this can still get re-orged
-	err = r.db.UpdateQuoteRequestStatus(ctx, req.TransactionId, reldb.RelayCompleted)
+	err = r.db.UpdateQuoteRequestStatus(ctx, req.TransactionId, reldb.RelayCompleted, nil)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}
@@ -361,7 +361,7 @@
 		return fmt.Errorf("could not submit transaction: %w", err)
 	}
 
-	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.ProvePosting)
+	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.ProvePosting, &request.Status)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}
@@ -375,7 +375,7 @@
 func (r *Relayer) handleProofProvided(ctx context.Context, req *fastbridge.FastBridgeBridgeProofProvided) (err error) {
 	// TODO: this can still get re-orged
 	// ALso: we should make sure the previous status  is ProvePosting
-	err = r.db.UpdateQuoteRequestStatus(ctx, req.TransactionId, reldb.ProvePosted)
+	err = r.db.UpdateQuoteRequestStatus(ctx, req.TransactionId, reldb.ProvePosted, nil)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}
@@ -408,7 +408,7 @@
 	}
 
 	if bs == fastbridge.RelayerClaimed.Int() {
-		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.ClaimCompleted)
+		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.ClaimCompleted, &request.Status)
 		if err != nil {
 			return fmt.Errorf("could not update request status: %w", err)
 		}
@@ -443,7 +443,7 @@
 		return fmt.Errorf("could not submit transaction: %w", err)
 	}
 
-	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.ClaimPending)
+	err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.ClaimPending, &request.Status)
 	if err != nil {
 		return fmt.Errorf("could not update request status: %w", err)
 	}
@@ -453,14 +453,14 @@
 // Error Handlers Only from this point below.
 //
 // handleNotEnoughInventory handles the not enough inventory status.
-func (q *QuoteRequestHandler) handleNotEnoughInventory(ctx context.Context, _ trace.Span, request reldb.QuoteRequest) (err error) {
+func (q *QuoteRequestHandler) handleNotEnoughInventory(ctx context.Context, span trace.Span, request reldb.QuoteRequest) (err error) {
 	committableBalance, err := q.Inventory.GetCommittableBalance(ctx, int(q.Dest.ChainID), request.Transaction.DestToken)
 	if err != nil {
 		return fmt.Errorf("could not get committable balance: %w", err)
 	}
 	// if committableBalance > destAmount
 	if committableBalance.Cmp(request.Transaction.DestAmount) > 0 {
-		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.CommittedPending)
+		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.CommittedPending, &request.Status)
 		if err != nil {
 			return fmt.Errorf("could not update request status: %w", err)
 		}