fix(rfq-relayer): gas estimation for zaps

services/rfq/api/model/request.go

@@ -59,6 +59,8 @@ type QuoteData struct {
 	ZapData           string  `json:"zap_data"`
 	ZapNative         string  `json:"zap_native"`
 	OriginAmountExact string  `json:"origin_amount_exact"`
+	OriginSender      string  `json:"origin_sender"`
+	DestRecipient     string  `json:"dest_recipient"`
 	DestAmount        *string `json:"dest_amount"`
 	RelayerAddress    *string `json:"relayer_address"`
 	QuoteID           *string `json:"quote_id"`

services/rfq/relayer/pricer/fee_pricer.go

@@ -3,6 +3,7 @@
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"strings"
@@ -141,7 +142,7 @@
 
 	// Calculate the static L2 fee if it won't be incorporated by directly estimating the relay() call
 	// in addZapFees().
-	if quoteRequest == nil || quoteRequest.Transaction.ZapData == nil || len(quoteRequest.Transaction.ZapData) == 0 {
+	if quoteRequest == nil || quoteRequest.Transaction.ZapNative == nil || quoteRequest.Transaction.ZapData == nil {
 		gasEstimate, err := f.config.GetDestGasEstimate(int(destination))
 		if err != nil {
 			return nil, fmt.Errorf("could not get dest gas estimate: %w", err)
@@ -183,7 +184,7 @@
 func (f *feePricer) addZapFees(ctx context.Context, destination uint32, denomToken string, quoteRequest *reldb.QuoteRequest, fee *big.Int) (*big.Int, error) {
 	span := trace.SpanFromContext(ctx)
 
-	if len(quoteRequest.Transaction.ZapData) > 0 {
+	if quoteRequest.Transaction.ZapData != nil {
 		gasEstimate, err := f.getZapGasEstimate(ctx, destination, quoteRequest)
 		if err != nil {
 			return nil, err
@@ -232,7 +233,12 @@
 		fastBridgeV2ABI = &parsedABI
 	}
 
-	encodedData, err := fastBridgeV2ABI.Pack(methodName, quoteRequest.RawRequest, f.relayerAddress)
+	rawRequest, err := encodeQuoteRequest(quoteRequest)
+	if err != nil {
+		return 0, fmt.Errorf("could not encode quote data: %w", err)
+	}
+
+	encodedData, err := fastBridgeV2ABI.Pack(methodName, rawRequest, f.relayerAddress)
 	if err != nil {
 		return 0, fmt.Errorf("could not encode function call: %w", err)
 	}
@@ -256,6 +262,76 @@
 	return gasEstimate, nil
 }
 
+func encodeQuoteRequest(quoteRequest *reldb.QuoteRequest) ([]byte, error) {
+	if quoteRequest == nil {
+		return nil, errors.New("quote request is nil")
+	}
+
+	// Create ABI types with error handling
+	uint16Type, err := abi.NewType("uint16", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint16 type: %w", err)
+	}
+	uint32Type, err := abi.NewType("uint32", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint32 type: %w", err)
+	}
+	addressType, err := abi.NewType("address", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create address type: %w", err)
+	}
+	uint256Type, err := abi.NewType("uint256", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create uint256 type: %w", err)
+	}
+	bytesType, err := abi.NewType("bytes", "", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create bytes type: %w", err)
+	}
+
+	// Define the ABI arguments
+	args := abi.Arguments{
+		{Type: uint16Type},  // version
+		{Type: uint32Type},  // originChainID
+		{Type: uint32Type},  // destChainID
+		{Type: addressType}, // originSender
+		{Type: addressType}, // destRecipient
+		{Type: addressType}, // originToken
+		{Type: addressType}, // destToken
+		{Type: uint256Type}, // originAmount
+		{Type: uint256Type}, // destAmount
+		{Type: uint256Type}, // originFeeAmount
+		{Type: uint256Type}, // deadline
+		{Type: uint256Type}, // nonce
+		{Type: addressType}, // exclusivityRelayer
+		{Type: uint256Type}, // exclusivityEndTime
+		{Type: uint256Type}, // zapNative
+		{Type: bytesType},   // zapData
+	}
+
+	tx := quoteRequest.Transaction
+
+	// Pack the arguments
+	return args.Pack(
+		uint16(2), // VERSION
+		tx.OriginChainId,
+		tx.DestChainId,
+		tx.OriginSender,
+		tx.DestRecipient,
+		tx.OriginToken,
+		tx.DestToken,
+		tx.OriginAmount,
+		tx.DestAmount,
+		tx.OriginFeeAmount,
+		tx.Deadline,
+		tx.Nonce,
+		tx.ExclusivityRelayer,
+		tx.ExclusivityEndTime,
+		tx.ZapNative,
+		tx.ZapData,
+	)
+}
+
 func (f *feePricer) GetTotalFee(parentCtx context.Context, origin, destination uint32, denomToken string, isQuote bool, quoteRequest *reldb.QuoteRequest) (_ *big.Int, err error) {
 	ctx, span := f.handler.Tracer().Start(parentCtx, "getTotalFee", trace.WithAttributes(
 		attribute.Int(metrics.Origin, int(origin)),

services/rfq/relayer/quoter/quoter.go

@@ -381,16 +381,11 @@
 		OriginAmountExact: originAmountExact,
 	}
 	if rfqRequest.Data.ZapNative != "" || rfqRequest.Data.ZapData != "" {
-		zapNative, ok := new(big.Int).SetString(rfqRequest.Data.ZapNative, 10)
-		if !ok {
-			return nil, fmt.Errorf("invalid zap native amount: %s", rfqRequest.Data.ZapNative)
-		}
-		quoteInput.QuoteRequest = &reldb.QuoteRequest{
-			Transaction: fastbridgev2.IFastBridgeV2BridgeTransactionV2{
-				ZapNative: zapNative,
-				ZapData:   []byte(rfqRequest.Data.ZapData),
-			},
+		quoteRequest, err := quoteDataToQuoteRequestV2(&rfqRequest.Data)
+		if err != nil {
+			return nil, fmt.Errorf("error converting quote data to quote request: %w", err)
 		}
+		quoteInput.QuoteRequest = quoteRequest
 	}
 
 	rawQuote, err := m.generateQuote(ctx, quoteInput)
@@ -432,6 +427,49 @@
 	return resp, nil
 }
 
+func quoteDataToQuoteRequestV2(quoteData *model.QuoteData) (*reldb.QuoteRequest, error) {
+	if quoteData == nil {
+		return nil, errors.New("quote data is nil")
+	}
+
+	originAmount, ok := new(big.Int).SetString(quoteData.OriginAmountExact, 10)
+	if !ok {
+		return nil, errors.New("invalid origin amount")
+	}
+	destAmount := originAmount // assume dest amount same as origin amount for estimation purposes
+	originFeeAmount := big.NewInt(0)
+	nonce := big.NewInt(0)
+	exclusivityEndTime := big.NewInt(0)
+	zapNative, ok := new(big.Int).SetString(quoteData.ZapNative, 10)
+	if !ok {
+		return nil, errors.New("invalid zap native")
+	}
+	deadline := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(256), nil), big.NewInt(1))
+	exclusivityRelayer := common.HexToAddress("")
+
+	quoteRequest := &reldb.QuoteRequest{
+		Transaction: fastbridgev2.IFastBridgeV2BridgeTransactionV2{
+			OriginChainId:      uint32(quoteData.OriginChainID),
+			DestChainId:        uint32(quoteData.DestChainID),
+			OriginSender:       common.HexToAddress(quoteData.OriginSender),
+			DestRecipient:      common.HexToAddress(quoteData.DestRecipient),
+			OriginToken:        common.HexToAddress(quoteData.OriginTokenAddr),
+			DestToken:          common.HexToAddress(quoteData.DestTokenAddr),
+			OriginAmount:       originAmount,
+			DestAmount:         destAmount,
+			OriginFeeAmount:    originFeeAmount,
+			Deadline:           deadline,
+			Nonce:              nonce,
+			ExclusivityRelayer: exclusivityRelayer,
+			ExclusivityEndTime: exclusivityEndTime,
+			ZapNative:          zapNative,
+			ZapData:            []byte(quoteData.ZapData),
+		},
+	}
+
+	return quoteRequest, nil
+}
+
 // GetPrice gets the price of a token.
 func (m *Manager) GetPrice(parentCtx context.Context, tokenName string) (_ float64, err error) {
 	ctx, span := m.metricsHandler.Tracer().Start(parentCtx, "GetPrice")