RFQ: support multiple rebalance methods

services/rfq/relayer/inventory/manager.go

@@ -2,6 +2,7 @@
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"strconv"
@@ -82,6 +83,9 @@
 	pendingHist metric.Float64Histogram
 }
 
+// ErrUnsupportedChain is the error for an unsupported chain.
+var ErrUnsupportedChain = errors.New("could not get gas balance for unsupported chain")
+
 // GetCommittableBalance gets the committable balances.
 func (i *inventoryManagerImpl) GetCommittableBalance(ctx context.Context, chainID int, token common.Address, options ...BalanceFetchArgOption) (*big.Int, error) {
 	committableBalances, err := i.GetCommittableBalances(ctx, options...)
@@ -94,7 +98,7 @@
 	if balance == nil && token == chain.EthAddress {
 		gasBalance, ok := i.gasBalances[chainID]
 		if !ok || gasBalance == nil {
-			return nil, fmt.Errorf("could not get gas balance for chain %d", chainID)
+			return nil, ErrUnsupportedChain
 		}
 		balance = i.gasBalances[chainID]
 	}
@@ -425,19 +429,19 @@
 // will be rebalanced.
 //
 //nolint:cyclop
-func (i *inventoryManagerImpl) Rebalance(parentCtx context.Context, chainID int, token common.Address) error {
-	// evaluate the rebalance method
-	method, err := i.cfg.GetRebalanceMethod(chainID, token.Hex())
+func (i *inventoryManagerImpl) Rebalance(parentCtx context.Context, chainID int, token common.Address) (err error) {
+	// short circuit if origin does not specify a rebalance method
+	methodOrigin, err := i.cfg.GetRebalanceMethod(chainID, token.Hex())
 	if err != nil {
-		return fmt.Errorf("could not get rebalance method: %w", err)
+		return fmt.Errorf("could not get origin rebalance method: %w", err)
 	}
-	if method == relconfig.RebalanceMethodNone {
+	if methodOrigin == relconfig.RebalanceMethodNone {
 		return nil
 	}
+
 	ctx, span := i.handler.Tracer().Start(parentCtx, "Rebalance", trace.WithAttributes(
 		attribute.Int(metrics.ChainID, chainID),
 		attribute.String("token", token.Hex()),
-		attribute.String("rebalance_method", method.String()),
 	))
 	defer func(err error) {
 		metrics.EndSpanWithErr(span, err)
@@ -475,9 +479,9 @@
 	}
 
 	// execute the rebalance
-	manager, ok := i.rebalanceManagers[method]
+	manager, ok := i.rebalanceManagers[rebalance.Method]
 	if !ok {
-		return fmt.Errorf("no rebalance manager for method: %s", method)
+		return fmt.Errorf("no rebalance manager for method: %s", methodOrigin)
 	}
 	err = manager.Execute(ctx, rebalance)
 	if err != nil {
@@ -506,7 +510,7 @@
 	return nil
 }
 
-//nolint:cyclop,gocognit
+//nolint:cyclop,gocognit,nilnil
 func getRebalance(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, chainID int, token common.Address) (rebalance *RebalanceData, err error) {
 	maintenancePct, err := cfg.GetMaintenanceBalancePct(chainID, token.Hex())
 	if err != nil {
@@ -522,54 +526,89 @@
 		}
 	}
 
-	// get total balance for given token across all chains
-	totalBalance := big.NewInt(0)
+	// evaluate the origin and dest of the rebalance based on min/max token balances
+	var destTokenData, originTokenData *TokenMetadata
 	for _, tokenMap := range tokens {
 		for _, tokenData := range tokenMap {
 			if tokenData.Name == rebalanceTokenData.Name {
-				totalBalance.Add(totalBalance, tokenData.Balance)
+				if destTokenData == nil || tokenData.Balance.Cmp(destTokenData.Balance) < 0 {
+					destTokenData = tokenData
+				}
+				if originTokenData == nil || tokenData.Balance.Cmp(originTokenData.Balance) > 0 {
+					originTokenData = tokenData
+				}
 			}
 		}
 	}
 
-	// check if any balances are below maintenance threshold
-	var minTokenData, maxTokenData *TokenMetadata
-	for _, tokenMap := range tokens {
-		for _, tokenData := range tokenMap {
-			if tokenData.Name == rebalanceTokenData.Name {
-				if minTokenData == nil || tokenData.Balance.Cmp(minTokenData.Balance) < 0 {
-					minTokenData = tokenData
-				}
-				if maxTokenData == nil || tokenData.Balance.Cmp(maxTokenData.Balance) > 0 {
-					maxTokenData = tokenData
-				}
-			}
+	// if the given chain is not the origin of the rebalance, no need to do anything
+	defer func() {
+		if span != nil {
+			span.SetAttributes(
+				attribute.Int("rebalance_chain_id", chainID),
+				attribute.Int("rebalance_origin", originTokenData.ChainID),
+				attribute.Int("rebalance_dest", destTokenData.ChainID),
+			)
+		}
+	}()
+	if originTokenData.ChainID != chainID {
+		return nil, nil
+	}
+
+	// validate the rebalance method pair
+	methodOrigin, err := cfg.GetRebalanceMethod(originTokenData.ChainID, originTokenData.Addr.Hex())
+	if err != nil {
+		return nil, fmt.Errorf("could not get origin rebalance method: %w", err)
+	}
+	methodDest, err := cfg.GetRebalanceMethod(destTokenData.ChainID, destTokenData.Addr.Hex())
+	if err != nil {
+		return nil, fmt.Errorf("could not get dest rebalance method: %w", err)
+	}
+	rebalanceMethod := relconfig.CoalesceRebalanceMethods(methodOrigin, methodDest)
+	defer func() {
+		if span != nil {
+			span.SetAttributes(attribute.Int("rebalance_method", int(rebalanceMethod)))
+			span.SetAttributes(attribute.Int("origin_rebalance_method", int(methodOrigin)))
+			span.SetAttributes(attribute.Int("dest_rebalance_method", int(methodDest)))
 		}
+	}()
+	if rebalanceMethod == relconfig.RebalanceMethodNone {
+		return nil, nil
 	}
 
 	// get the initialPct for the origin chain
-	initialPct, err := cfg.GetInitialBalancePct(maxTokenData.ChainID, maxTokenData.Addr.Hex())
+	initialPct, err := cfg.GetInitialBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex())
 	if err != nil {
 		return nil, fmt.Errorf("could not get initial pct: %w", err)
 	}
+
+	// calculate maintenance threshold relative to total balance
+	totalBalance := big.NewInt(0)
+	for _, tokenMap := range tokens {
+		for _, tokenData := range tokenMap {
+			if tokenData.Name == rebalanceTokenData.Name {
+				totalBalance.Add(totalBalance, tokenData.Balance)
+			}
+		}
+	}
 	maintenanceThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil)
 	if span != nil {
 		span.SetAttributes(attribute.Float64("maintenance_pct", maintenancePct))
 		span.SetAttributes(attribute.Float64("initial_pct", initialPct))
-		span.SetAttributes(attribute.String("max_token_balance", maxTokenData.Balance.String()))
-		span.SetAttributes(attribute.String("min_token_balance", minTokenData.Balance.String()))
+		span.SetAttributes(attribute.String("max_token_balance", originTokenData.Balance.String()))
+		span.SetAttributes(attribute.String("min_token_balance", destTokenData.Balance.String()))
 		span.SetAttributes(attribute.String("total_balance", totalBalance.String()))
 		span.SetAttributes(attribute.String("maintenance_thresh", maintenanceThresh.String()))
 	}
 
 	// check if the minimum balance is below the threshold and trigger rebalance
-	if minTokenData.Balance.Cmp(maintenanceThresh) > 0 {
+	if destTokenData.Balance.Cmp(maintenanceThresh) > 0 {
 		return rebalance, nil
 	}
 
 	// calculate the amount to rebalance vs the initial threshold on origin
 	initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil)
-	amount := new(big.Int).Sub(maxTokenData.Balance, initialThresh)
+	amount := new(big.Int).Sub(originTokenData.Balance, initialThresh)
 
 	// no need to rebalance since amount would not be positive
 	if amount.Cmp(big.NewInt(0)) <= 0 {
@@ -578,15 +617,15 @@
 	}
 
 	// filter the rebalance amount by the configured min
-	minAmount := cfg.GetMinRebalanceAmount(maxTokenData.ChainID, maxTokenData.Addr)
+	minAmount := cfg.GetMinRebalanceAmount(originTokenData.ChainID, originTokenData.Addr)
 	if amount.Cmp(minAmount) < 0 {
 		// no need to rebalance
 		//nolint:nilnil
 		return nil, nil
 	}
 
 	// clip the rebalance amount by the configured max
-	maxAmount := cfg.GetMaxRebalanceAmount(maxTokenData.ChainID, maxTokenData.Addr)
+	maxAmount := cfg.GetMaxRebalanceAmount(originTokenData.ChainID, originTokenData.Addr)
 	if amount.Cmp(maxAmount) > 0 {
 		amount = maxAmount
 	}
@@ -599,9 +638,10 @@
 	}
 
 	rebalance = &RebalanceData{
-		OriginMetadata: maxTokenData,
-		DestMetadata:   minTokenData,
+		OriginMetadata: originTokenData,
+		DestMetadata:   destTokenData,
 		Amount:         amount,
+		Method:         rebalanceMethod,
 	}
 	return rebalance, nil
 }

services/rfq/relayer/inventory/manager_test.go

@@ -88,7 +88,7 @@ func (i *InventoryTestSuite) TestGetRebalance() {
 			usdcDataDest.Addr: &usdcDataDest,
 		},
 	}
-	getConfig := func(minRebalanceAmount, maxRebalanceAmount string) relconfig.Config {
+	getConfig := func(minRebalanceAmount, maxRebalanceAmount string, originMethod, destMethod relconfig.RebalanceMethod) relconfig.Config {
 		return relconfig.Config{
 			Chains: map[int]relconfig.ChainConfig{
 				origin: {
@@ -100,6 +100,7 @@ func (i *InventoryTestSuite) TestGetRebalance() {
 							InitialBalancePct:     50,
 							MinRebalanceAmount:    minRebalanceAmount,
 							MaxRebalanceAmount:    maxRebalanceAmount,
+							RebalanceMethod:       originMethod.String(),
 						},
 					},
 				},
@@ -112,6 +113,7 @@ func (i *InventoryTestSuite) TestGetRebalance() {
 							InitialBalancePct:     50,
 							MinRebalanceAmount:    minRebalanceAmount,
 							MaxRebalanceAmount:    maxRebalanceAmount,
+							RebalanceMethod:       destMethod.String(),
 						},
 					},
 				},
@@ -124,6 +126,7 @@ func (i *InventoryTestSuite) TestGetRebalance() {
 							InitialBalancePct:     0,
 							MinRebalanceAmount:    minRebalanceAmount,
 							MaxRebalanceAmount:    maxRebalanceAmount,
+							RebalanceMethod:       destMethod.String(),
 						},
 					},
 				},
@@ -132,7 +135,7 @@ func (i *InventoryTestSuite) TestGetRebalance() {
 	}
 
 	// 10 USDC on both chains; no rebalance needed
-	cfg := getConfig("", "")
+	cfg := getConfig("", "", relconfig.RebalanceMethodSynapseCCTP, relconfig.RebalanceMethodSynapseCCTP)
 	usdcDataOrigin.Balance = big.NewInt(1e7)
 	usdcDataDest.Balance = big.NewInt(1e7)
 	rebalance, err := inventory.GetRebalance(cfg, tokens, origin, usdcDataOrigin.Addr)
@@ -155,23 +158,37 @@ func (i *InventoryTestSuite) TestGetRebalance() {
 		OriginMetadata: &usdcDataOrigin,
 		DestMetadata:   &usdcDataDest,
 		Amount:         big.NewInt(4e6),
+		Method:         relconfig.RebalanceMethodSynapseCCTP,
 	}
 	i.Equal(expected, rebalance)
 
+	// Set rebalance methods to mismatch
+	cfg = getConfig("", "", relconfig.RebalanceMethodCircleCCTP, relconfig.RebalanceMethodSynapseCCTP)
+	rebalance, err = inventory.GetRebalance(cfg, tokens, origin, usdcDataOrigin.Addr)
+	i.NoError(err)
+	i.Nil(rebalance)
+
+	// Set one rebalance method to None
+	cfg = getConfig("", "", relconfig.RebalanceMethodNone, relconfig.RebalanceMethodSynapseCCTP)
+	rebalance, err = inventory.GetRebalance(cfg, tokens, origin, usdcDataOrigin.Addr)
+	i.NoError(err)
+	i.Nil(rebalance)
+
 	// Set min rebalance amount
-	cfgWithMax := getConfig("10", "1000000000")
+	cfgWithMax := getConfig("10", "1000000000", relconfig.RebalanceMethodSynapseCCTP, relconfig.RebalanceMethodSynapseCCTP)
 	rebalance, err = inventory.GetRebalance(cfgWithMax, tokens, origin, usdcDataOrigin.Addr)
 	i.NoError(err)
 	i.Nil(rebalance)
 
 	// Set max rebalance amount
-	cfgWithMax = getConfig("0", "1.1")
+	cfgWithMax = getConfig("0", "1.1", relconfig.RebalanceMethodSynapseCCTP, relconfig.RebalanceMethodSynapseCCTP)
 	rebalance, err = inventory.GetRebalance(cfgWithMax, tokens, origin, usdcDataOrigin.Addr)
 	i.NoError(err)
 	expected = &inventory.RebalanceData{
 		OriginMetadata: &usdcDataOrigin,
 		DestMetadata:   &usdcDataDest,
 		Amount:         big.NewInt(1.1e6),
+		Method:         relconfig.RebalanceMethodSynapseCCTP,
 	}
 	i.Equal(expected, rebalance)
 

services/rfq/relayer/inventory/rebalance.go

@@ -3,13 +3,16 @@ package inventory
 import (
 	"context"
 	"math/big"
+
+	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
 )
 
 // RebalanceData contains metadata for a rebalance action.
 type RebalanceData struct {
 	OriginMetadata *TokenMetadata
 	DestMetadata   *TokenMetadata
 	Amount         *big.Int
+	Method         relconfig.RebalanceMethod
 }
 
 // RebalanceManager is the interface for the rebalance manager.

services/rfq/relayer/pricer/fee_pricer.go

@@ -276,11 +276,13 @@
 		if err != nil {
 			return nil, err
 		}
-		header, err := client.HeaderByNumber(ctx, nil)
+		gasPrice, err = client.SuggestGasPrice(ctx)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("failed to suggest gas price on chain %d: %w", chainID, err)
+		}
+		if gasPrice == nil {
+			return nil, fmt.Errorf("gas price is nil on chain %d", chainID)
 		}
-		gasPrice = header.BaseFee
 		f.gasPriceCache.Set(chainID, gasPrice, 0)
 	} else {
 		gasPrice = gasPriceItem.Value()