RFQ Potential Speed Ups

[trajan0x]

Additional speed ups:

• HasSufficientGas
• IsProfitable
• ShouldProcess in paralell

Commitable quotes calculated on db side (less data sent over the wire)

Paralellize HasSufficientGasOrigin and Dest

[greptile-apps]

To speed up the RFQ process, follow these steps:

1. Parallelize HasSufficientGasOrigin and HasSufficientGasDest in gasMiddleware:

   func (r *Relayer) gasMiddleware(next func(ctx context.Context, span trace.Span, req reldb.QuoteRequest) error) func(ctx context.Context, span trace.Span, req reldb.QuoteRequest) error {
       return func(ctx context.Context, span trace.Span, req reldb.QuoteRequest) (err error) {
           var sufficientGasOrigin, sufficientGasDest bool
           g, gctx := errgroup.WithContext(ctx)
   
           g.Go(func() error {
               sufficientGasOrigin, err = r.inventory.HasSufficientGas(gctx, int(req.Transaction.OriginChainId), nil)
               return err
           })
   
           g.Go(func() error {
               var destGasValue *big.Int
               if req.Transaction.DestToken == chain.EthAddress && !isInFlight {
                   destGasValue = req.Transaction.DestAmount
                   span.SetAttributes(attribute.String("dest_gas_value", destGasValue.String()))
               }
               sufficientGasDest, err = r.inventory.HasSufficientGas(gctx, int(req.Transaction.DestChainId), destGasValue)
               return err
           })
   
           if err := g.Wait(); err != nil {
               return fmt.Errorf("could not check gas: %w", err)
           }
   
           if !sufficientGasOrigin || !sufficientGasDest {
               return nil
           }
   
           return next(ctx, span, req)
       }
   }

2. Parallelize HasSufficientGas, IsProfitable, and ShouldProcess in handleSeen:

   func (q *QuoteRequestHandler) handleSeen(ctx context.Context, span trace.Span, request reldb.QuoteRequest) (err error) {
       g, gctx := errgroup.WithContext(ctx)
       var shouldProcess, isProfitable bool
   
       g.Go(func() error {
           shouldProcess, err = q.Quoter.ShouldProcess(gctx, request)
           return err
       })
   
       g.Go(func() error {
           isProfitable, err = q.Quoter.IsProfitable(gctx, request)
           return err
       })
   
       if err := g.Wait(); err != nil {
           return fmt.Errorf("could not determine if should process or is profitable: %w", err)
       }
   
       if !shouldProcess {
           err = q.db.UpdateQuoteRequestStatus(ctx, request.TransactionID, reldb.WillNotProcess)
           if err != nil {
               return fmt.Errorf("could not update request status: %w", err)
           }
           return nil
       }
   
       if !isProfitable {
           span.AddEvent("quote is not profitable")
           return nil
       }
   
       // existing code...
   }

3. Calculate committable quotes on the database side:

   Modify the database query to calculate committable quotes directly in the database and return the results. This will reduce the amount of data sent over the wire and improve performance.

   // Example: Modify the query in reldb/service.go
   func (db *Service) GetCommittableBalances(ctx context.Context) (map[int]map[common.Address]*big.Int, error) {
       // Modify the query to calculate committable balances directly in the database
       query := `SELECT chain_id, token_address, SUM(balance) as committable_balance FROM balances WHERE status = 'committable' GROUP BY chain_id, token_address`
       // Execute the query and process the results
       // ...
   }

4. Update tests in quoter_test.go to reflect these changes:

   func (s *QuoterSuite) TestParallelizedFunctions() {
       // Add tests for parallelized functions
       // ...
   }

References

/services/rfq/relayer/quoter/quoter.go
/services/rfq/relayer/service/statushandler.go
/services/rfq/relayer/service/handlers.go
/services/rfq/relayer/quoter/quoter_test.go
/services/rfq/relayer/reldb/base/model.go
/services/rfq/api/docs/swagger.yaml
/services/rfq/relayer/README.md

Ask Greptile