refactor(rfq-relayer): rebalancing with multiple tokens (#3003)

* WIP: rebalance candidates * WIP: impl getRebalances() * Feat: update Rebalance() interface and execution * Feat: add TokenName to rebalance models * Feat: filter pending rebalances on token name * WIP: rebalance tests * Feat: working basic tests * Feat: more rebalance tests * Cleanup: logs * Cleanup: unused ctx * Fix: build * Cleanup: lint * Cleanup: add supportsRebalanceMethod() helper * [goreleaser] * Cleanup: lint * Cleanup: lint * [goreleaser] * Feat: cleaner initial rebalance amount calculation * Feat: add documentation for getRebalanceAmount() * Cleanup: logs * Cleanup: docs * [goreleaser] * Fix: use origin initial pct * [goreleaser] * Feat: more test cases * [goreleaser] * cleanup * [goreleaser] * Fix: set TokenName when storing rebalances * [goreleaser] * Feat: check rebalance contents in e2e test * Feat: add tracing * [goreleaser] * Feat: add tracing * [goreleaser] * Feat: approval tracing * [goreleaser] * Fix: approve gateway router for scroll rebalances * [goreleaser] * Fix: get current block from dest when checking relay confirmations * [goreleaser] * Fix: add build:go directive in package.json --------- Co-authored-by: Trajan0x <trajan0x@users.noreply.github.com>
synapsecns · Sep 4, 2024 · dfb97a8 · dfb97a8
1 parent a364bbd
commit dfb97a8
Show file tree

Hide file tree

Showing 14 changed files with 673 additions and 586 deletions.
diff --git a/.golangci.yml b/.golangci.yml
@@ -111,6 +111,7 @@ issues:
       linters:
         - revive
         - stylecheck
+        - dupl
     # wrapping errors when exporting for testing is tedious
     - path: export_test\.go
       linters:

diff --git a/services/rfq/e2e/rfq_test.go b/services/rfq/e2e/rfq_test.go
@@ -246,7 +246,21 @@ func (i *IntegrationSuite) TestUSDCtoUSDC() {
 		}
 		originPendingRebals, err := i.store.GetPendingRebalances(i.GetTestContext(), uint64(i.originBackend.GetChainID()))
 		i.NoError(err)
-		return len(originPendingRebals) > 0
+		if len(originPendingRebals) == 0 {
+			return false
+		}
+		expectedRebalance := reldb.Rebalance{
+			RebalanceID:     originPendingRebals[0].RebalanceID,
+			OriginAmount:    big.NewInt(445_000_000),
+			Origin:          uint64(i.originBackend.GetChainID()),
+			Destination:     uint64(i.destBackend.GetChainID()),
+			OriginTxHash:    originPendingRebals[0].OriginTxHash,
+			OriginTokenAddr: originPendingRebals[0].OriginTokenAddr,
+			Status:          reldb.RebalancePending,
+			TokenName:       "MockMintBurnToken",
+		}
+		i.Equal(expectedRebalance, *originPendingRebals[0])
+		return true
 	})
 
 	i.Eventually(func() bool {

diff --git a/services/rfq/relayer/inventory/circle.go b/services/rfq/relayer/inventory/circle.go
@@ -242,10 +242,12 @@ func (c *rebalanceManagerCircleCCTP) Execute(parentCtx context.Context, rebalanc
 
 	// store the rebalance in the db
 	rebalanceModel := reldb.Rebalance{
-		Origin:       uint64(rebalance.OriginMetadata.ChainID),
-		Destination:  uint64(rebalance.DestMetadata.ChainID),
-		OriginAmount: rebalance.Amount,
-		Status:       reldb.RebalanceInitiated,
+		Origin:          uint64(rebalance.OriginMetadata.ChainID),
+		Destination:     uint64(rebalance.DestMetadata.ChainID),
+		OriginAmount:    rebalance.Amount,
+		Status:          reldb.RebalanceInitiated,
+		OriginTokenAddr: rebalance.OriginMetadata.Addr,
+		TokenName:       rebalance.OriginMetadata.Name,
 	}
 	err = c.db.StoreRebalance(ctx, rebalanceModel)
 	if err != nil {

diff --git a/services/rfq/relayer/inventory/export_test.go b/services/rfq/relayer/inventory/export_test.go
@@ -1,16 +1,13 @@
 package inventory
 
 import (
+	"context"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
 )
 
 // GetRebalance is a wrapper around the internal getRebalance function.
-func GetRebalance(cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, chainID int, token common.Address) (*RebalanceData, error) {
-	return getRebalance(nil, cfg, tokens, chainID, token)
-}
-
-// GetRebalanceMetadatas is a wrapper around the internal getRebalanceMetadatas function.
-func GetRebalanceMetadatas(cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, tokenName string, methods []relconfig.RebalanceMethod) (originTokenData, destTokenData *TokenMetadata, method relconfig.RebalanceMethod) {
-	return getRebalanceMetadatas(cfg, tokens, tokenName, methods)
+func GetRebalances(ctx context.Context, cfg relconfig.Config, inv map[int]map[common.Address]*TokenMetadata) (rebalances map[string]*RebalanceData, err error) {
+	return getRebalances(ctx, cfg, inv)
 }
diff --git a/services/rfq/relayer/inventory/manager.go b/services/rfq/relayer/inventory/manager.go
@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
-	"strconv"
 	"sync"
 	"time"
 
@@ -49,9 +48,8 @@ type Manager interface {
 	ApproveAllTokens(ctx context.Context) error
 	// HasSufficientGas checks if there is sufficient gas for a given route.
 	HasSufficientGas(ctx context.Context, chainID int, gasValue *big.Int) (bool, error)
-	// Rebalance checks whether a given token should be rebalanced, and
-	// executes the rebalance if necessary.
-	Rebalance(ctx context.Context, chainID int, token common.Address) error
+	// Rebalance attempts any rebalances that could be executed across all supported tokens and chains.
+	Rebalance(ctx context.Context) error
 	// GetTokenMetadata gets the metadata for a token.
 	GetTokenMetadata(chainID int, token common.Address) (*TokenMetadata, error)
 }
@@ -273,13 +271,10 @@ func (i *inventoryManagerImpl) Start(ctx context.Context) error {
 						metrics.EndSpanWithErr(span, err)
 						return fmt.Errorf("could not refresh balances: %w", err)
 					}
-					for chainID, chainConfig := range i.cfg.Chains {
-						for tokenName, tokenConfig := range chainConfig.Tokens {
-							err = i.Rebalance(rebalanceCtx, chainID, common.HexToAddress(tokenConfig.Address))
-							if err != nil {
-								logger.Errorf("could not rebalance %s on chain %d: %v", tokenName, chainID, err)
-							}
-						}
+
+					err = i.Rebalance(rebalanceCtx)
+					if err != nil {
+						logger.Errorf("could not rebalance: %v", err)
 					}
 
 					metrics.EndSpanWithErr(span, err)
@@ -299,7 +294,12 @@ const maxBatchSize = 10
 
 // ApproveAllTokens approves all checks if allowance is set and if not approves.
 // nolint:gocognit,nestif,cyclop
-func (i *inventoryManagerImpl) ApproveAllTokens(ctx context.Context) error {
+func (i *inventoryManagerImpl) ApproveAllTokens(ctx context.Context) (err error) {
+	ctx, span := i.handler.Tracer().Start(ctx, "approveAllTokens")
+	defer func() {
+		metrics.EndSpanWithErr(span, err)
+	}()
+
 	i.mux.RLock()
 	defer i.mux.RUnlock()
 
@@ -338,6 +338,11 @@ func (i *inventoryManagerImpl) ApproveAllTokens(ctx context.Context) error {
 
 			parentAddr, addrErr := i.cfg.GetL1GatewayAddress(chainID)
 			if addrErr == nil {
+				span.AddEvent(fmt.Sprintf("got l1 gateway address: %s", parentAddr.Hex()))
+				err = i.approve(ctx, tokenAddr, parentAddr, backendClient)
+				if err != nil {
+					return fmt.Errorf("could not approve L1GatewayRouter contract: %w", err)
+				}
 				contract, err := l1gateway.NewL1GatewayRouter(parentAddr, backendClient)
 				if err != nil {
 					return fmt.Errorf("could not get L1Gateway contract: %w", err)
@@ -346,6 +351,7 @@ func (i *inventoryManagerImpl) ApproveAllTokens(ctx context.Context) error {
 				if err != nil {
 					return fmt.Errorf("could not get L1ERC20Gateway address: %w", err)
 				}
+				span.AddEvent(fmt.Sprintf("got l1 erc20 gateway address: %s", contractAddr.Hex()))
 				err = i.approve(ctx, tokenAddr, contractAddr, backendClient)
 				if err != nil {
 					return fmt.Errorf("could not approve L1ERC20Gateway contract: %w", err)
@@ -354,6 +360,11 @@ func (i *inventoryManagerImpl) ApproveAllTokens(ctx context.Context) error {
 
 			parentAddr, addrErr = i.cfg.GetL2GatewayAddress(chainID)
 			if addrErr == nil {
+				span.AddEvent(fmt.Sprintf("got l2 gateway address: %s", parentAddr.Hex()))
+				err = i.approve(ctx, tokenAddr, parentAddr, backendClient)
+				if err != nil {
+					return fmt.Errorf("could not approve L2GatewayRouter contract: %w", err)
+				}
 				contract, err := l2gateway.NewL2GatewayRouter(parentAddr, backendClient)
 				if err != nil {
 					return fmt.Errorf("could not get L2Gateway contract: %w", err)
@@ -362,6 +373,7 @@ func (i *inventoryManagerImpl) ApproveAllTokens(ctx context.Context) error {
 				if err != nil {
 					return fmt.Errorf("could not get L2ERC20Gateway address: %w", err)
 				}
+				span.AddEvent(fmt.Sprintf("got l2 erc20 gateway address: %s", contractAddr.Hex()))
 				err = i.approve(ctx, tokenAddr, contractAddr, backendClient)
 				if err != nil {
 					return fmt.Errorf("could not approve L2ERC20Gateway contract: %w", err)
@@ -458,50 +470,58 @@ func (i *inventoryManagerImpl) HasSufficientGas(parentCtx context.Context, chain
 	return sufficient, nil
 }
 
-// Rebalance checks whether a given token should be rebalanced, and executes the rebalance if necessary.
-// Note that if there are multiple tokens whose balance is below the maintenance balance, only the lowest balance
-// will be rebalanced.
-//
-//nolint:cyclop
-func (i *inventoryManagerImpl) Rebalance(parentCtx context.Context, chainID int, token common.Address) (err error) {
-	// short circuit if origin does not specify a rebalance method
-	methodsOrigin, err := i.cfg.GetRebalanceMethods(chainID, token.Hex())
-	if err != nil {
-		return fmt.Errorf("could not get origin rebalance method: %w", err)
-	}
-	if len(methodsOrigin) == 0 {
-		return nil
-	}
-
-	ctx, span := i.handler.Tracer().Start(parentCtx, "Rebalance", trace.WithAttributes(
-		attribute.Int(metrics.ChainID, chainID),
-		attribute.String("token", token.Hex()),
-	))
+func (i *inventoryManagerImpl) Rebalance(ctx context.Context) (err error) {
+	ctx, span := i.handler.Tracer().Start(ctx, "Rebalance")
 	defer func(err error) {
 		metrics.EndSpanWithErr(span, err)
 	}(err)
 
-	// build the rebalance action
-	rebalance, err := getRebalance(span, i.cfg, i.tokens, chainID, token)
+	rebalances, err := getRebalances(ctx, i.cfg, i.tokens)
 	if err != nil {
-		return fmt.Errorf("could not get rebalance: %w", err)
+		return fmt.Errorf("could not get rebalances: %w", err)
 	}
-	if rebalance == nil || rebalance.Amount.Cmp(big.NewInt(0)) <= 0 {
-		return nil
+
+	for tokenName, rebalance := range rebalances {
+		if rebalance == nil || rebalance.Amount == nil {
+			continue
+		}
+
+		err = i.tryExecuteRebalance(ctx, rebalance)
+		if err != nil {
+			return fmt.Errorf("could not execute rebalance for token %s: %w", tokenName, err)
+		}
 	}
-	span.SetAttributes(
-		attribute.String("rebalance_origin", strconv.Itoa(rebalance.OriginMetadata.ChainID)),
-		attribute.String("rebalance_dest", strconv.Itoa(rebalance.DestMetadata.ChainID)),
+
+	return nil
+}
+
+func (i *inventoryManagerImpl) tryExecuteRebalance(ctx context.Context, rebalance *RebalanceData) (err error) {
+	ctx, span := i.handler.Tracer().Start(ctx, "tryExecuteRebalance", trace.WithAttributes(
+		attribute.Int("origin", rebalance.OriginMetadata.ChainID),
+		attribute.Int("dest", rebalance.DestMetadata.ChainID),
+		attribute.String("origin_token", rebalance.OriginMetadata.Addr.Hex()),
+		attribute.String("dest_token", rebalance.DestMetadata.Addr.Hex()),
+		attribute.String("origin_balance", rebalance.OriginMetadata.Balance.String()),
+		attribute.String("dest_balance", rebalance.DestMetadata.Balance.String()),
 		attribute.String("rebalance_amount", rebalance.Amount.String()),
-		attribute.String("rebalance_method", rebalance.Method.String()),
-	)
+		attribute.String("token_name", rebalance.OriginMetadata.Name),
+	))
+	defer func(err error) {
+		metrics.EndSpanWithErr(span, err)
+	}(err)
 
 	// make sure there are no pending rebalances that touch the given path
 	pendingRebalances, err := i.db.GetPendingRebalances(ctx, uint64(rebalance.OriginMetadata.ChainID), uint64(rebalance.DestMetadata.ChainID))
 	if err != nil {
 		return fmt.Errorf("could not check pending rebalance: %w", err)
 	}
-	pending := len(pendingRebalances) > 0
+	var pending bool
+	for _, pendingRebalance := range pendingRebalances {
+		if pendingRebalance.TokenName == rebalance.OriginMetadata.Name {
+			pending = true
+			break
+		}
+	}
 	span.SetAttributes(attribute.Bool("rebalance_pending", pending))
 	if pending {
 		return nil
@@ -517,6 +537,7 @@ func (i *inventoryManagerImpl) Rebalance(parentCtx context.Context, chainID int,
 	if err != nil {
 		return fmt.Errorf("could not execute rebalance: %w", err)
 	}
+
 	return nil
 }