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/contracts/bridgetransactionv2/generate.go

@@ -0,0 +1,4 @@
+// Package bridgetransactionv2 is the bridge transaction contract.
+package bridgetransactionv2
+
+//go:generate go run github.com/synapsecns/sanguine/tools/abigen generate --sol ../../../../packages/contracts-rfq/flattened/BridgeTransactionV2Harness.sol --pkg bridgetransactionv2 --sol-version 0.8.24 --filename bridgetransactionv2 --evm-version istanbul

services/rfq/contracts/bridgetransactionv2/helper.go

@@ -0,0 +1,35 @@
+package bridgetransactionv2
+
+import (
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+)
+
+// BridgeTransactionV2Ref is a bound fast bridge contract that returns the address of the contract.
+//
+//nolint:golint
+type BridgeTransactionV2Ref struct {
+	*BridgeTransactionV2Harness
+	address common.Address
+}
+
+// Address gets the ocntract address.
+func (f *BridgeTransactionV2Ref) Address() common.Address {
+	return f.address
+}
+
+// NewBridgeTransactionV2Ref creates a new fast bridge mock contract with a ref.
+func NewBridgeTransactionV2Ref(address common.Address, backend bind.ContractBackend) (*BridgeTransactionV2Ref, error) {
+	bridgetransactionv2, err := NewBridgeTransactionV2Harness(address, backend)
+	if err != nil {
+		return nil, err
+	}
+
+	return &BridgeTransactionV2Ref{
+		BridgeTransactionV2Harness: bridgetransactionv2,
+		address:                    address,
+	}, nil
+}
+
+var _ vm.ContractRef = &BridgeTransactionV2Ref{}

services/rfq/e2e/rfq_test.go

@@ -21,10 +21,12 @@
 	cctpTest "github.com/synapsecns/sanguine/services/cctp-relayer/testutil"
 	omnirpcClient "github.com/synapsecns/sanguine/services/omnirpc/client"
 	"github.com/synapsecns/sanguine/services/rfq/api/client"
+	"github.com/synapsecns/sanguine/services/rfq/contracts/bridgetransactionv2"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridgev2"
 	"github.com/synapsecns/sanguine/services/rfq/guard/guarddb"
 	guardService "github.com/synapsecns/sanguine/services/rfq/guard/service"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/chain"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/service"
 	"github.com/synapsecns/sanguine/services/rfq/testutil"
@@ -773,3 +775,59 @@
 		return true
 	})
 }
+
+func (i *IntegrationSuite) TestEncodeBridgeTransactionParity() {
+	_, handle := i.manager.GetBridgeTransactionV2(i.GetTestContext(), i.originBackend)
+
+	originUSDC, _ := i.cctpDeployManager.GetMockMintBurnTokenType(i.GetTestContext(), i.originBackend)
+	destUSDC, _ := i.cctpDeployManager.GetMockMintBurnTokenType(i.GetTestContext(), i.destBackend)
+	deadline := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(256), nil), big.NewInt(1))
+	// zapData := []byte("Hello, world!")
+	zapData := []byte{}
+
+	bridgeTx := bridgetransactionv2.IFastBridgeV2BridgeTransactionV2{
+		OriginChainId:      uint32(i.originBackend.GetChainID()),
+		DestChainId:        uint32(i.destBackend.GetChainID()),
+		OriginSender:       i.userWallet.Address(),
+		DestRecipient:      i.userWallet.Address(),
+		OriginToken:        originUSDC.Address(),
+		DestToken:          destUSDC.Address(),
+		OriginAmount:       big.NewInt(1000),
+		DestAmount:         big.NewInt(1000),
+		OriginFeeAmount:    big.NewInt(10),
+		Deadline:           big.NewInt(0),
+		Nonce:              big.NewInt(0),
+		ExclusivityRelayer: i.relayerWallet.Address(),
+		ExclusivityEndTime: big.NewInt(0),
+		ZapNative:          big.NewInt(100),
+		ZapData:            zapData,
+	}
+
+	fmt.Printf("address: %v\n", handle.Address())
+	expectedEncoded, err := handle.EncodeV2(&bind.CallOpts{Context: i.GetTestContext()}, bridgeTx)
+	i.NoError(err)
+	fmt.Printf("Expected: %x\n", expectedEncoded)
+
+	tx := fastbridgev2.IFastBridgeV2BridgeTransactionV2{
+		OriginChainId:      uint32(i.originBackend.GetChainID()),
+		DestChainId:        uint32(i.destBackend.GetChainID()),
+		OriginSender:       i.userWallet.Address(),
+		DestRecipient:      i.userWallet.Address(),
+		OriginToken:        originUSDC.Address(),
+		DestToken:          destUSDC.Address(),
+		OriginAmount:       big.NewInt(1000),
+		DestAmount:         big.NewInt(1000),
+		OriginFeeAmount:    big.NewInt(10),
+		Deadline:           deadline,
+		Nonce:              big.NewInt(0),
+		ExclusivityRelayer: common.HexToAddress(""),
+		ExclusivityEndTime: big.NewInt(0),
+		ZapNative:          big.NewInt(100),
+		ZapData:            zapData,
+	}
+
+	encoded, err := chain.EncodeQuoteRequest(tx)
+	i.NoError(err)
+
+	i.Equal(expectedEncoded, encoded)
+}

services/rfq/relayer/chain/encoding.go

@@ -0,0 +1,83 @@
+package chain
+
+import (
+	"encoding/binary"
+	"math/big"
+
+	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridgev2"
+)
+
+const (
+	// Field sizes in bytes
+	sizeVersion = 2
+	sizeChainID = 4
+	sizeAddress = 20
+	sizeUint256 = 32
+
+	// Field offsets in bytes
+	offsetVersion            = 0
+	offsetOriginChainID      = offsetVersion + sizeVersion
+	offsetDestChainID        = offsetOriginChainID + sizeChainID
+	offsetOriginSender       = offsetDestChainID + sizeChainID
+	offsetDestRecipient      = offsetOriginSender + sizeAddress
+	offsetOriginToken        = offsetDestRecipient + sizeAddress
+	offsetDestToken          = offsetOriginToken + sizeAddress
+	offsetOriginAmount       = offsetDestToken + sizeAddress
+	offsetDestAmount         = offsetOriginAmount + sizeUint256
+	offsetOriginFeeAmount    = offsetDestAmount + sizeUint256
+	offsetDeadline           = offsetOriginFeeAmount + sizeUint256
+	offsetNonce              = offsetDeadline + sizeUint256
+	offsetExclusivityRelayer = offsetNonce + sizeUint256
+	offsetExclusivityEndTime = offsetExclusivityRelayer + sizeAddress
+	offsetZapNative          = offsetExclusivityEndTime + sizeUint256
+	offsetZapData            = offsetZapNative + sizeUint256
+)
+
+// Helper function to properly encode uint256
+func padUint256(b *big.Int) []byte {
+	// Convert big.Int to bytes
+	bytes := b.Bytes()
+	// Create 32-byte array (initialized to zeros)
+	result := make([]byte, 32)
+	// Copy bytes to right side of array (left-pad with zeros)
+	copy(result[32-len(bytes):], bytes)
+	return result
+}
+
+// EncodeQuoteRequest encodes a quote request into a byte array.
+func EncodeQuoteRequest(tx fastbridgev2.IFastBridgeV2BridgeTransactionV2) ([]byte, error) {
+	result := make([]byte, offsetZapData)
+
+	// Version
+	result[offsetVersion] = 0
+	result[offsetVersion+1] = 2
+
+	// Chain IDs
+	binary.BigEndian.PutUint32(result[offsetOriginChainID:offsetOriginChainID+sizeChainID], tx.OriginChainId)
+	binary.BigEndian.PutUint32(result[offsetDestChainID:offsetDestChainID+sizeChainID], tx.DestChainId)
+
+	// Addresses
+	copy(result[offsetOriginSender:offsetOriginSender+sizeAddress], tx.OriginSender.Bytes())
+	copy(result[offsetDestRecipient:offsetDestRecipient+sizeAddress], tx.DestRecipient.Bytes())
+	copy(result[offsetOriginToken:offsetOriginToken+sizeAddress], tx.OriginToken.Bytes())
+	copy(result[offsetDestToken:offsetDestToken+sizeAddress], tx.DestToken.Bytes())
+
+	// uint256 values
+	copy(result[offsetOriginAmount:offsetOriginAmount+sizeUint256], padUint256(tx.OriginAmount))
+	copy(result[offsetDestAmount:offsetDestAmount+sizeUint256], padUint256(tx.DestAmount))
+	copy(result[offsetOriginFeeAmount:offsetOriginFeeAmount+sizeUint256], padUint256(tx.OriginFeeAmount))
+	copy(result[offsetDeadline:offsetDeadline+sizeUint256], padUint256(tx.Deadline))
+	copy(result[offsetNonce:offsetNonce+sizeUint256], padUint256(tx.Nonce))
+
+	// Exclusivity address
+	copy(result[offsetExclusivityRelayer:offsetExclusivityRelayer+sizeAddress], tx.ExclusivityRelayer.Bytes())
+
+	// More uint256 values
+	copy(result[offsetExclusivityEndTime:offsetExclusivityEndTime+sizeUint256], padUint256(tx.ExclusivityEndTime))
+	copy(result[offsetZapNative:offsetZapNative+sizeUint256], padUint256(tx.ZapNative))
+
+	// Append ZapData
+	result = append(result, tx.ZapData...)
+
+	return result, nil
+}

services/rfq/relayer/pricer/fee_pricer.go

@@ -15,6 +15,7 @@ import (
 	"github.com/synapsecns/sanguine/core/metrics"
 	"github.com/synapsecns/sanguine/ethergo/submitter"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridgev2"
+	"github.com/synapsecns/sanguine/services/rfq/relayer/chain"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
 	"go.opentelemetry.io/otel/attribute"
@@ -141,7 +142,7 @@ func (f *feePricer) GetDestinationFee(parentCtx context.Context, _, destination
 
 	// 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) GetDestinationFee(parentCtx context.Context, _, destination
 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 @@ func (f *feePricer) getZapGasEstimate(ctx context.Context, destination uint32, q
 		fastBridgeV2ABI = &parsedABI
 	}
 
-	encodedData, err := fastBridgeV2ABI.Pack(methodName, quoteRequest.RawRequest, f.relayerAddress)
+	rawRequest, err := chain.EncodeQuoteRequest(quoteRequest.Transaction)
+	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)
 	}

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")

services/rfq/testutil/contracttype.go

@@ -4,6 +4,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/compiler"
 	"github.com/synapsecns/sanguine/ethergo/backends/base"
 	"github.com/synapsecns/sanguine/ethergo/contracts"
+	"github.com/synapsecns/sanguine/services/rfq/contracts/bridgetransactionv2"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/dai"
 	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/fastbridgemockv2"
@@ -58,6 +59,8 @@ const (
 	FastBridgeMockType // FastBridgeMock
 	// RecipientMockType is a mock contract for testing fast bridge interactions.
 	RecipientMockType // RecipientMock
+	// BridgeTransactionV2Type is a bridge transaction contract for testing fast bridge interactions.
+	BridgeTransactionV2Type // BridgeTransactionV2
 	// WETH9Type  is the weth 9 contract.
 	WETH9Type // WETH9
 	// USDTType is the tether type.
@@ -100,6 +103,8 @@ func (c contractTypeImpl) ContractInfo() *compiler.Contract {
 		return fastbridgemockv2.Contracts["solidity/FastBridgeMock.sol:FastBridgeMock"]
 	case RecipientMockType:
 		return recipientmock.Contracts["solidity/RecipientMock.sol:RecipientMock"]
+	case BridgeTransactionV2Type:
+		return bridgetransactionv2.Contracts["solidity/BridgeTransactionV2Harness.sol:BridgeTransactionV2Harness"]
 	case WETH9Type:
 		return weth9.Contracts["/solidity/WETH9.sol:WETH9"]
 	case USDTType: