feat(rfq-relayer): wait for finality before proving

services/rfq/guard/guardconfig/config.go

@@ -116,7 +116,7 @@
 	for chainID, chainCfg := range relayerCfg.GetChains() {
 		cfg.Chains[chainID] = ChainConfig{
 			RFQAddress:    chainCfg.RFQAddress,
-			Confirmations: chainCfg.Confirmations,
+			Confirmations: chainCfg.FinalityConfirmations,
 		}
 	}
 	return cfg

services/rfq/guard/guarddb/base/model.go

@@ -42,6 +42,8 @@
 	TxHash string
 	// Status is the status of the event
 	Status guarddb.PendingProvenStatus
+	// BlockNumber is the block number of the event
+	BlockNumber uint64
 }
 
 // FromPendingProven converts a quote request to an object that can be stored in the db.
@@ -52,6 +54,7 @@
 		TransactionID:  hexutil.Encode(proven.TransactionID[:]),
 		TxHash:         proven.TxHash.Hex(),
 		Status:         proven.Status,
+		BlockNumber:    proven.BlockNumber,
 	}
 }
 
@@ -73,6 +76,7 @@
 		TransactionID:  transactionID,
 		TxHash:         common.HexToHash(p.TxHash),
 		Status:         p.Status,
+		BlockNumber:    p.BlockNumber,
 	}, nil
 }
 

services/rfq/guard/guarddb/db.go

@@ -64,6 +64,7 @@ type PendingProven struct {
 	TransactionID  [32]byte
 	TxHash         common.Hash
 	Status         PendingProvenStatus
+	BlockNumber    uint64
 }
 
 // PendingProvenStatus is the status of a quote request in the db.

services/rfq/guard/service/handlers.go

@@ -82,6 +82,7 @@
 		TransactionID:  event.TransactionId,
 		TxHash:         event.TransactionHash,
 		Status:         guarddb.ProveCalled,
+		BlockNumber:    event.Raw.BlockNumber,
 	}
 	err = g.db.StorePendingProven(ctx, proven)
 	if err != nil {
@@ -115,7 +116,17 @@
 		metrics.EndSpanWithErr(span, err)
 	}()
 
-	// first, get the corresponding bridge request
+	// first, verify that the prove tx is finalized
+	finalized, err := g.isFinalized(ctx, int(proven.Origin), proven.BlockNumber)
+	if err != nil {
+		return fmt.Errorf("could not check if tx is finalized: %w", err)
+	}
+	span.SetAttributes(attribute.Bool("finalized", finalized))
+	if !finalized {
+		return nil
+	}
+
+	// get the corresponding bridge request
 	bridgeRequest, err := g.db.GetBridgeRequestByID(ctx, proven.TransactionID)
 	if err != nil {
 		return fmt.Errorf("could not get bridge request for txid %s: %w", hexutil.Encode(proven.TransactionID[:]), err)
@@ -242,3 +253,32 @@
 	}
 	return true
 }
+
+// isFinalized checks if a transaction is finalized versus the configured confirmations threshold.
+func (g *Guard) isFinalized(ctx context.Context, chainID int, txBlockNumber uint64) (bool, error) {
+	span := trace.SpanFromContext(ctx)
+
+	client, err := g.client.GetChainClient(ctx, chainID)
+	if err != nil {
+		return false, fmt.Errorf("could not get chain client: %w", err)
+	}
+
+	currentBlockNumber, err := client.BlockNumber(ctx)
+	if err != nil {
+		return false, fmt.Errorf("could not get block number: %w", err)
+	}
+
+	chainCfg, ok := g.cfg.Chains[chainID]
+	if !ok {
+		return false, fmt.Errorf("could not get chain config for chain %d", chainID)
+	}
+	threshBlockNumber := txBlockNumber + chainCfg.Confirmations
+	span.SetAttributes(
+		attribute.Int("chain_id", chainID),
+		attribute.Int("current_block_number", int(currentBlockNumber)),
+		attribute.Int("tx_block_number", int(txBlockNumber)),
+		attribute.Int("confirmations", int(chainCfg.Confirmations)),
+	)
+
+	return currentBlockNumber >= threshBlockNumber, nil
+}

services/rfq/relayer/relconfig/config.go

@@ -74,6 +74,8 @@ type ChainConfig struct {
 	RFQAddress string `yaml:"rfq_address"`
 	// Confirmations is the number of required confirmations.
 	Confirmations uint64 `yaml:"confirmations"`
+	// FinalityConfirmations is the number of required confirmations before proving.
+	FinalityConfirmations uint64 `yaml:"prove_confirmations"`
 	// Tokens is a map of token name -> token config.
 	Tokens map[string]TokenConfig `yaml:"tokens"`
 	// NativeToken is the native token of the chain (pays gas).

services/rfq/relayer/relconfig/getters.go

@@ -215,6 +215,20 @@
 	return value, nil
 }
 
+// GetFinalityConfirmations returns the FinalityConfirmations for the given chainID.
+func (c Config) GetFinalityConfirmations(chainID int) (value uint64, err error) {
+	rawValue, err := c.getChainConfigValue(chainID, "FinalityConfirmations")
+	if err != nil {
+		return value, err
+	}
+
+	value, ok := rawValue.(uint64)
+	if !ok {
+		return value, fmt.Errorf("failed to cast FinalityConfirmations to int")
+	}
+	return value, nil
+}
+
 // GetNativeToken returns the NativeToken for the given chainID.
 func (c Config) GetNativeToken(chainID int) (value string, err error) {
 	rawValue, err := c.getChainConfigValue(chainID, "NativeToken")

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

@@ -133,7 +133,7 @@ func (s Store) UpdateRelayNonce(ctx context.Context, id [32]byte, nonce uint64)
 }
 
 func isValidStateTransition(prevStatus, status reldb.QuoteRequestStatus) bool {
-	if status == reldb.DeadlineExceeded || status == reldb.WillNotProcess {
+	if status == reldb.DeadlineExceeded || status == reldb.WillNotProcess || status == reldb.RelayRaceLost {
 		return true
 	}
 	return status >= prevStatus

services/rfq/relayer/service/handlers.go

@@ -378,8 +378,36 @@
 // Step 6: ProvePosting
 //
 // This is the sixth step in the bridge process. Here we submit the claim transaction to the origin chain.
-func (q *QuoteRequestHandler) handleRelayCompleted(ctx context.Context, _ trace.Span, request reldb.QuoteRequest) (err error) {
-	// relays been completed, it's time to go back to the origin chain and try to prove
+func (q *QuoteRequestHandler) handleRelayCompleted(ctx context.Context, span trace.Span, request reldb.QuoteRequest) (err error) {
+	// fetch the block of the relay transaction to confirm that it has been finalized
+	relayBlockNumber, err := q.getRelayBlockNumber(ctx, request)
+	if err != nil {
+		// relay tx must have gotten reorged; mark as RelayRaceLost
+		span.SetAttributes(attribute.String("receipt_error", err.Error()))
+		err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.RelayRaceLost, nil)
+		if err != nil {
+			return fmt.Errorf("could not update request status: %w", err)
+		}
+		return fmt.Errorf("could not get relay block number: %w", err)
+	}
+
+	currentBlockNumber := q.Origin.LatestBlock()
+	proveConfirmations, err := q.cfg.GetFinalityConfirmations(int(q.Dest.ChainID))
+	if err != nil {
+		return fmt.Errorf("could not get prove confirmations: %w", err)
+	}
+
+	span.SetAttributes(
+		attribute.Int("current_block_number", int(currentBlockNumber)),
+		attribute.Int("relay_block_number", int(relayBlockNumber)),
+		attribute.Int("prove_confirmations", int(proveConfirmations)),
+	)
+	if currentBlockNumber < relayBlockNumber+proveConfirmations {
+		span.AddEvent("not enough confirmations")
+		return nil
+	}
+
+	// relay has been finalized, it's time to go back to the origin chain and try to prove
 	_, err = q.Origin.SubmitTransaction(ctx, func(transactor *bind.TransactOpts) (tx *types.Transaction, err error) {
 		tx, err = q.Origin.Bridge.Prove(transactor, request.RawRequest, request.DestTxHash)
 		if err != nil {
@@ -399,6 +427,43 @@
 	return nil
 }
 
+// getRelayBlockNumber fetches the block number of the relay transaction for a given quote request.
+func (q *QuoteRequestHandler) getRelayBlockNumber(ctx context.Context, request reldb.QuoteRequest) (blockNumber uint64, err error) {
+	// fetch the transaction receipt for corresponding tx hash
+	var receipt *types.Receipt
+	err = retry.WithBackoff(ctx, func(context.Context) error {
+		receipt, err = q.Dest.Client.TransactionReceipt(ctx, request.DestTxHash)
+		if err != nil {
+			return fmt.Errorf("could not get transaction receipt: %w", err)
+		}
+		return nil
+	}, retry.WithMaxTotalTime(15*time.Second))
+	if err != nil {
+		return blockNumber, fmt.Errorf("could not get get receipt: %w", err)
+	}
+	parser, err := fastbridge.NewParser(q.Dest.Bridge.Address())
+	if err != nil {
+		return blockNumber, fmt.Errorf("could not create parser: %w", err)
+	}
+
+	// check that a Relayed event was emitted
+	for _, log := range receipt.Logs {
+		if log == nil {
+			continue
+		}
+		_, parsedEvent, ok := parser.ParseEvent(*log)
+		if !ok {
+			continue
+		}
+		_, ok = parsedEvent.(*fastbridge.FastBridgeBridgeRelayed)
+		if ok {
+			return receipt.BlockNumber.Uint64(), nil
+		}
+	}
+
+	return blockNumber, fmt.Errorf("relayed event not found for dest tx hash: %s", request.DestTxHash.Hex())
+}
+
 // handleProofProvided handles the ProofProvided event emitted by the Bridge.
 // Step 7: ProvePosted
 //

services/rfq/relayer/service/statushandler.go

@@ -15,6 +15,7 @@
 	"github.com/synapsecns/sanguine/services/rfq/relayer/chain"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/inventory"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/quoter"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
 	"github.com/synapsecns/sanguine/services/rfq/util"
 	"go.opentelemetry.io/otel/attribute"
@@ -54,6 +55,8 @@
 	handlerMtx mapmutex.StringMapMutex
 	// balanceMtx is the mutex for balances.
 	balanceMtx mapmutex.StringMapMutex
+	// cfg is the relayer config.
+	cfg relconfig.Config
 }
 
 func getBalanceMtxKey(chainID uint32, token common.Address) string {
@@ -88,6 +91,7 @@
 		mutexMiddlewareFunc: r.mutexMiddleware,
 		handlerMtx:          r.handlerMtx,
 		balanceMtx:          r.balanceMtx,
+		cfg:                 r.cfg,
 	}
 
 	// wrap in deadline middleware since the relay has not yet happened