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

services/rfq/guard/guardconfig/config.go

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

services/rfq/guard/service/handlers.go

@@ -115,7 +115,17 @@
 		metrics.EndSpanWithErr(span, err)
 	}()
 
-	// first, get the corresponding bridge request
+	// first, verify that the prove tx is finalized
+	finalized, err := g.isFinalized(ctx, proven.TxHash, int(proven.Origin))
+	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 +252,36 @@
 	}
 	return true
 }
+
+// isFinalized checks if a transaction is finalized versus the configured confirmations threshold.
+func (g *Guard) isFinalized(ctx context.Context, txHash common.Hash, chainID int) (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)
+	}
+	receipt, err := client.TransactionReceipt(ctx, txHash)
+	if err != nil {
+		return false, fmt.Errorf("could not get receipt: %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 := uint64(receipt.BlockNumber.Int64()) + chainCfg.Confirmations
+	span.SetAttributes(
+		attribute.String("tx_hash", txHash.Hex()),
+		attribute.Int("chain_id", chainID),
+		attribute.Int64("current_block_number", int64(currentBlockNumber)),
+		attribute.Int64("receipt_block_number", receipt.BlockNumber.Int64()),
+		attribute.Int("confirmations", int(chainCfg.Confirmations)),
+	)
+
+	return receipt != nil && 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/service/handlers.go

@@ -378,8 +378,28 @@
 // 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) {
+	// first, ensure that enough confirmations have passed before proving
+	receipt, err := q.Dest.Client.TransactionReceipt(ctx, request.DestTxHash)
+	if err != nil {
+		return fmt.Errorf("could not get transaction receipt: %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("dest_block_number", int(receipt.BlockNumber.Int64())),
+		attribute.Int("prove_confirmations", int(proveConfirmations)),
+	)
+	if currentBlockNumber < request.BlockNumber+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 {

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