RFQ: rebalance edge cases & refactoring #2613
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
WalkthroughThe recent updates focus on refining the rebalance functionality across the RFQ relayer inventory system. Changes include the introduction of new methods for calculating rebalances, adjustments to token balance management, and the removal of certain functions to streamline operations. The modifications aim to enhance the efficiency and accuracy of inventory management within the system. Changes
Thank you for using CodeRabbit. We offer it for free to the OSS community and would appreciate your support in helping us grow. If you find it useful, would you consider giving us a shout-out on your favorite social media? TipsChatThere are 3 ways to chat with CodeRabbit:
Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (invoked as PR comments)
Additionally, you can add CodeRabbit Configration File (
|
Deploying sanguine-fe with
|
| Latest commit: |
ee7e2c0
|
| Status: | ✅ Deploy successful! |
| Preview URL: | https://7718aabc.sanguine-fe.pages.dev |
| Branch Preview URL: | https://fix-multiple-rebalance.sanguine-fe.pages.dev |
Codecov ReportAttention: Patch coverage is
Additional details and impacted files@@ Coverage Diff @@
## master #2613 +/- ##
===================================================
+ Coverage 39.67339% 39.68210% +0.00871%
===================================================
Files 179 180 +1
Lines 14574 14596 +22
Branches 80 80
===================================================
+ Hits 5782 5792 +10
- Misses 8035 8042 +7
- Partials 757 762 +5
Flags with carried forward coverage won't be shown. Click here to find out more. ☔ View full report in Codecov by Sentry. |
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
Out of diff range and nitpick comments (22)
services/rfq/relayer/inventory/manager.go (22)
Line range hint
136-136: Consider adding more detailed documentation for theManagerinterface to better explain its responsibilities and usage.
Line range hint
138-138: TheStartmethod in theManagerinterface could benefit from a more detailed comment explaining what starting the inventory manager entails.
Line range hint
140-140: Clarify in the comment what "committable balance" means in the context of theGetCommittableBalancemethod.
Line range hint
142-142: TheGetCommittableBalancesmethod's comment should explain what it returns and under what conditions.
Line range hint
144-144: TheApproveAllTokensmethod's comment should detail the criteria for token approval.
Line range hint
146-146: TheHasSufficientGasmethod's comment should explain how it determines if there is sufficient gas.
Line range hint
148-148: TheRebalancemethod's comment should explain the criteria for deciding whether a rebalance is necessary.
Line range hint
150-150: TheGetTokenMetadatamethod's comment should describe what metadata it retrieves and from where.
Line range hint
152-152: TheinventoryManagerImplstruct could use a detailed comment explaining its role and the significance of its fields.
Line range hint
154-154: Thetokensfield ininventoryManagerImplshould have a comment explaining its structure and purpose.
Line range hint
156-156: ThegasBalancesfield ininventoryManagerImplshould have a comment explaining what balances it tracks and why.
Line range hint
158-158: Themuxfield ininventoryManagerImplshould have a comment explaining its use for thread safety in accessing the other fields.
Line range hint
160-160: Thehandlerfield ininventoryManagerImplshould have a comment explaining its role in handling metrics.
Line range hint
162-162: Thecfgfield ininventoryManagerImplshould have a comment explaining what configuration it holds.
Line range hint
164-164: TherelayerAddressfield ininventoryManagerImplshould have a comment explaining its significance.
Line range hint
166-166: ThechainClientfield ininventoryManagerImplshould have a comment explaining its role in interacting with blockchain networks.
Line range hint
168-168: ThetxSubmitterfield ininventoryManagerImplshould have a comment explaining its role in submitting transactions.
Line range hint
170-170: TherebalanceManagersfield ininventoryManagerImplshould have a comment explaining its role in managing different rebalance strategies.
Line range hint
172-172: Thedbfield ininventoryManagerImplshould have a comment explaining its role in interacting with the database.
Line range hint
174-174: Themeterfield ininventoryManagerImplshould have a comment explaining its role in metrics collection.
Line range hint
176-176: ThebalanceHistfield ininventoryManagerImplshould have a comment explaining what it measures.
Line range hint
178-178: ThependingHistfield ininventoryManagerImplshould have a comment explaining what it measures.
Review Details
Configuration used: .coderabbit.yaml
Review profile: CHILL
Files selected for processing (5)
- services/rfq/relayer/inventory/manager.go (1 hunks)
- services/rfq/relayer/inventory/manager_test.go (3 hunks)
- services/rfq/relayer/inventory/rebalance.go (2 hunks)
- services/rfq/relayer/relconfig/enum.go (1 hunks)
- services/rfq/relayer/service/chainindexer.go (1 hunks)
Files skipped from review due to trivial changes (1)
- services/rfq/relayer/relconfig/enum.go
Additional comments not posted (5)
services/rfq/relayer/service/chainindexer.go (1)
198-198: Ensure that the removal of theRebalancemethod call inhandleDepositClaimeddoes not affect other functionalities or error handling.services/rfq/relayer/inventory/rebalance.go (1)
30-94: Ensure that the newgetRebalancefunction correctly handles all edge cases, especially with the return ofnilvalues under various conditions.services/rfq/relayer/inventory/manager_test.go (2)
70-84: Ensure that the initialization ofBalanceinTokenMetadatainstances is correctly handled and does not introduce any side effects.
94-104: Verify that the newtokensWithExtramap is utilized correctly throughout the test scenarios and does not lead to any unintended behavior.services/rfq/relayer/inventory/manager.go (1)
Line range hint
1-1: Ensure all necessary imports are included and unused imports are removed to maintain cleanliness and reduce the binary size.Verification successful
The verification process has confirmed that all imports listed in the
manager.gofile are indeed used within the file. Each import was checked for its presence in the code outside of the import declarations, and no unused imports were found. This aligns with the best practices of maintaining clean and efficient code by avoiding unnecessary imports.
- All imports in
manager.goare utilized, ensuring no increase in binary size due to unused code.Scripts Executed
The following scripts were executed for the analysis:
Script:
#!/bin/bash # Description: Verify that all imports in `manager.go` are used within the file. # Test: Search for unused imports. Expect: No output if all imports are used. rg --type go --files-with-matches --invert-match 'import' 'services/rfq/relayer/inventory/manager.go' | xargs -I {} rg --type go 'import' {}Length of output: 149
Script:
#!/bin/bash # Description: List all imports in `manager.go` and check if they are used elsewhere in the file. # List all imports imports=$(rg --type go '^import \(".*"\)$|^import \w+$' services/rfq/relayer/inventory/manager.go -o --no-filename) # Check each import for usage echo "$imports" | while read -r import; do # Extract the actual import path import_path=$(echo $import | sed -n 's/import \(.*\)/\1/p') # Check if the import path is used elsewhere in the file rg --type go -q "$import_path" services/rfq/relayer/inventory/manager.go if [ $? -ne 0 ]; then echo "Unused import found: $import_path" fi doneLength of output: 299
Script:
#!/bin/bash # Description: Correctly list all imports in `manager.go` and check if they are used elsewhere in the file. # Correctly list all imports, accounting for single and grouped imports imports=$(rg --type go 'import \(([^)]+)\)|import \w+' services/rfq/relayer/inventory/manager.go --no-filename -o) # Check each import for usage echo "$imports" | grep -oP '(?<=\").*(?=\")' | while read -r import_path; do # Check if the import path is used elsewhere in the file rg --type go -q "$import_path" services/rfq/relayer/inventory/manager.go if [ $? -ne 0 ]; then echo "Unused import found: $import_path" fi doneLength of output: 178
Script:
#!/bin/bash # Description: Directly check for any import statements in `manager.go`. # Display any import statements from the file rg --type go 'import' services/rfq/relayer/inventory/manager.goLength of output: 72
Script:
#!/bin/bash # Description: Extract specific imports from the import block in `manager.go` and check their usage. # Extract specific imports from the import block imports=$(rg --type go -A 10 'import \(' services/rfq/relayer/inventory/manager.go | grep -v 'import (' | grep -oP '\".*\"' | tr -d '\"') # Check each import for usage echo "$imports" | while read -r import_path; do # Check if the import path is used elsewhere in the file rg --type go -q "$import_path" services/rfq/relayer/inventory/manager.go if [ $? -ne 0 ]; then echo "Unused import found: $import_path" fi doneLength of output: 1498
Comment on lines
124
to
211
| // getRebalanceAmount calculates the amount to rebalance based on the configured thresholds. | ||
| func getRebalanceAmount(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, originTokenData, destTokenData *TokenMetadata) (amount *big.Int, err error) { | ||
| // get the maintenance and initial values for the destination chain | ||
| maintenancePct, err := cfg.GetMaintenanceBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | ||
| } | ||
| initialPct, err := cfg.GetInitialBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("could not get initial pct: %w", err) | ||
| } | ||
|
|
||
| // calculate maintenance threshold relative to total balance | ||
| tokenName := originTokenData.Name | ||
| totalBalance := big.NewInt(0) | ||
| for _, tokenMap := range tokens { | ||
| for _, tokenData := range tokenMap { | ||
| if tokenData.Name == tokenName { | ||
| 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", 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())) | ||
| } | ||
|
|
||
| // no need to rebalance if we are not below maintenance threshold on destination | ||
| if destTokenData.Balance.Cmp(maintenanceThresh) > 0 { | ||
| return nil, nil | ||
| } | ||
|
|
||
| // calculate the amount to rebalance vs the initial threshold on destination | ||
| initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil) | ||
| 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 { | ||
| //nolint:nilnil | ||
| return nil, nil | ||
| } | ||
|
|
||
| // filter the rebalance amount by the configured min | ||
| 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(originTokenData.ChainID, originTokenData.Addr) | ||
| if amount.Cmp(maxAmount) > 0 { | ||
| amount = maxAmount | ||
| } | ||
| if span != nil { | ||
| span.SetAttributes( | ||
| attribute.String("initial_thresh", initialThresh.String()), | ||
| attribute.String("rebalance_amount", amount.String()), | ||
| attribute.String("max_rebalance_amount", maxAmount.String()), | ||
| ) | ||
| } | ||
|
|
||
| // make sure that the rebalance amount does not take origin below maintenance threshold | ||
| maintenancePctOrigin, err := cfg.GetMaintenanceBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex()) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | ||
| } | ||
| maintenanceThreshOrigin, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePctOrigin/100)).Int(nil) | ||
| newBalanceOrigin := new(big.Int).Sub(originTokenData.Balance, amount) | ||
| if newBalanceOrigin.Cmp(maintenanceThreshOrigin) < 0 { | ||
| if span != nil { | ||
| span.SetAttributes( | ||
| attribute.Float64("maintenance_pct_origin", maintenancePctOrigin), | ||
| attribute.String("maintenance_thresh_origin", maintenanceThreshOrigin.String()), | ||
| attribute.String("new_balance_origin", newBalanceOrigin.String()), | ||
| ) | ||
| } | ||
| return nil, nil | ||
| } | ||
|
|
||
| return amount, nil | ||
| } |
There was a problem hiding this comment.
Optimize the getRebalanceAmount function by ensuring that calculations and conditional checks are efficient and correctly implemented.
- maintenanceThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil)
+ maintenanceThresh, err := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil)
+ if err != nil {
+ return nil, fmt.Errorf("error calculating maintenance threshold: %w", err)
+ }Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation.
Suggested change
| // getRebalanceAmount calculates the amount to rebalance based on the configured thresholds. | |
| func getRebalanceAmount(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, originTokenData, destTokenData *TokenMetadata) (amount *big.Int, err error) { | |
| // get the maintenance and initial values for the destination chain | |
| maintenancePct, err := cfg.GetMaintenanceBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| initialPct, err := cfg.GetInitialBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get initial pct: %w", err) | |
| } | |
| // calculate maintenance threshold relative to total balance | |
| tokenName := originTokenData.Name | |
| totalBalance := big.NewInt(0) | |
| for _, tokenMap := range tokens { | |
| for _, tokenData := range tokenMap { | |
| if tokenData.Name == tokenName { | |
| 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", 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())) | |
| } | |
| // no need to rebalance if we are not below maintenance threshold on destination | |
| if destTokenData.Balance.Cmp(maintenanceThresh) > 0 { | |
| return nil, nil | |
| } | |
| // calculate the amount to rebalance vs the initial threshold on destination | |
| initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil) | |
| 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 { | |
| //nolint:nilnil | |
| return nil, nil | |
| } | |
| // filter the rebalance amount by the configured min | |
| 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(originTokenData.ChainID, originTokenData.Addr) | |
| if amount.Cmp(maxAmount) > 0 { | |
| amount = maxAmount | |
| } | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.String("initial_thresh", initialThresh.String()), | |
| attribute.String("rebalance_amount", amount.String()), | |
| attribute.String("max_rebalance_amount", maxAmount.String()), | |
| ) | |
| } | |
| // make sure that the rebalance amount does not take origin below maintenance threshold | |
| maintenancePctOrigin, err := cfg.GetMaintenanceBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| maintenanceThreshOrigin, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePctOrigin/100)).Int(nil) | |
| newBalanceOrigin := new(big.Int).Sub(originTokenData.Balance, amount) | |
| if newBalanceOrigin.Cmp(maintenanceThreshOrigin) < 0 { | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.Float64("maintenance_pct_origin", maintenancePctOrigin), | |
| attribute.String("maintenance_thresh_origin", maintenanceThreshOrigin.String()), | |
| attribute.String("new_balance_origin", newBalanceOrigin.String()), | |
| ) | |
| } | |
| return nil, nil | |
| } | |
| return amount, nil | |
| } | |
| // getRebalanceAmount calculates the amount to rebalance based on the configured thresholds. | |
| func getRebalanceAmount(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, originTokenData, destTokenData *TokenMetadata) (amount *big.Int, err error) { | |
| // get the maintenance and initial values for the destination chain | |
| maintenancePct, err := cfg.GetMaintenanceBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| initialPct, err := cfg.GetInitialBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get initial pct: %w", err) | |
| } | |
| // calculate maintenance threshold relative to total balance | |
| tokenName := originTokenData.Name | |
| totalBalance := big.NewInt(0) | |
| for _, tokenMap := range tokens { | |
| for _, tokenData := range tokenMap { | |
| if tokenData.Name == tokenName { | |
| totalBalance.Add(totalBalance, tokenData.Balance) | |
| } | |
| } | |
| } | |
| maintenanceThresh, err := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil) | |
| if err != nil { | |
| return nil, fmt.Errorf("error calculating maintenance threshold: %w", err) | |
| } | |
| if span != nil { | |
| span.SetAttributes(attribute.Float64("maintenance_pct", maintenancePct)) | |
| span.SetAttributes(attribute.Float64("initial_pct", initialPct)) | |
| 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())) | |
| } | |
| // no need to rebalance if we are not below maintenance threshold on destination | |
| if destTokenData.Balance.Cmp(maintenanceThresh) > 0 { | |
| return nil, nil | |
| } | |
| // calculate the amount to rebalance vs the initial threshold on destination | |
| initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil) | |
| 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 { | |
| //nolint:nilnil | |
| return nil, nil | |
| } | |
| // filter the rebalance amount by the configured min | |
| 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(originTokenData.ChainID, originTokenData.Addr) | |
| if amount.Cmp(maxAmount) > 0 { | |
| amount = maxAmount | |
| } | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.String("initial_thresh", initialThresh.String()), | |
| attribute.String("rebalance_amount", amount.String()), | |
| attribute.String("max_rebalance_amount", maxAmount.String()), | |
| ) | |
| } | |
| // make sure that the rebalance amount does not take origin below maintenance threshold | |
| maintenancePctOrigin, err := cfg.GetMaintenanceBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| maintenanceThreshOrigin, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePctOrigin/100)).Int(nil) | |
| newBalanceOrigin := new(big.Int).Sub(originTokenData.Balance, amount) | |
| if newBalanceOrigin.Cmp(maintenanceThreshOrigin) < 0 { | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.Float64("maintenance_pct_origin", maintenancePctOrigin), | |
| attribute.String("maintenance_thresh_origin", maintenanceThreshOrigin.String()), | |
| attribute.String("new_balance_origin", newBalanceOrigin.String()), | |
| ) | |
| } | |
| return nil, nil | |
| } | |
| return amount, nil | |
| } |
There was a problem hiding this comment.
Actionable comments posted: 2
Review Details
Configuration used: .coderabbit.yaml
Review profile: CHILL
Files selected for processing (2)
- services/rfq/relayer/inventory/rebalance.go (2 hunks)
- services/rfq/relayer/service/chainindexer.go (2 hunks)
Files skipped from review as they are similar to previous changes (1)
- services/rfq/relayer/service/chainindexer.go
Additional comments not posted (1)
services/rfq/relayer/inventory/rebalance.go (1)
30-94: LGTM! ThegetRebalancefunction effectively builds a rebalance action considering various conditions and error handling.
Comment on lines
+96
to
+122
| // getRebalanceMetadatas finds the origin and dest token metadata based on the configured rebalance method. | ||
| func getRebalanceMetadatas(cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, tokenName string, method relconfig.RebalanceMethod) (originTokenData, destTokenData *TokenMetadata) { | ||
| for _, tokenMap := range tokens { | ||
| for _, tokenData := range tokenMap { | ||
| if tokenData.Name == tokenName { | ||
| // make sure that the token is compatible with our rebalance method | ||
| tokenMethod, tokenErr := cfg.GetRebalanceMethod(tokenData.ChainID, tokenData.Addr.Hex()) | ||
| if tokenErr != nil { | ||
| logger.Errorf("could not get token rebalance method: %v", tokenErr) | ||
| continue | ||
| } | ||
| if tokenMethod != method { | ||
| continue | ||
| } | ||
|
|
||
| // assign origin / dest metadata based on min / max balances | ||
| if originTokenData == nil || tokenData.Balance.Cmp(originTokenData.Balance) > 0 { | ||
| originTokenData = tokenData | ||
| } | ||
| if destTokenData == nil || tokenData.Balance.Cmp(destTokenData.Balance) < 0 { | ||
| destTokenData = tokenData | ||
| } | ||
| } | ||
| } | ||
| } | ||
| return originTokenData, destTokenData | ||
| } |
There was a problem hiding this comment.
Improve error logging by including token address in the error message for better traceability.
- logger.Errorf("could not get token rebalance method: %v", tokenErr)
+ if tokenErr != nil {
+ logger.Errorf("could not get token rebalance method for token %s: %v", tokenData.Addr.Hex(), tokenErr)
+ }Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation.
Suggested change
| // getRebalanceMetadatas finds the origin and dest token metadata based on the configured rebalance method. | |
| func getRebalanceMetadatas(cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, tokenName string, method relconfig.RebalanceMethod) (originTokenData, destTokenData *TokenMetadata) { | |
| for _, tokenMap := range tokens { | |
| for _, tokenData := range tokenMap { | |
| if tokenData.Name == tokenName { | |
| // make sure that the token is compatible with our rebalance method | |
| tokenMethod, tokenErr := cfg.GetRebalanceMethod(tokenData.ChainID, tokenData.Addr.Hex()) | |
| if tokenErr != nil { | |
| logger.Errorf("could not get token rebalance method: %v", tokenErr) | |
| continue | |
| } | |
| if tokenMethod != method { | |
| continue | |
| } | |
| // assign origin / dest metadata based on min / max balances | |
| if originTokenData == nil || tokenData.Balance.Cmp(originTokenData.Balance) > 0 { | |
| originTokenData = tokenData | |
| } | |
| if destTokenData == nil || tokenData.Balance.Cmp(destTokenData.Balance) < 0 { | |
| destTokenData = tokenData | |
| } | |
| } | |
| } | |
| } | |
| return originTokenData, destTokenData | |
| } | |
| // getRebalanceMetadatas finds the origin and dest token metadata based on the configured rebalance method. | |
| func getRebalanceMetadatas(cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, tokenName string, method relconfig.RebalanceMethod) (originTokenData, destTokenData *TokenMetadata) { | |
| for _, tokenMap := range tokens { | |
| for _, tokenData := range tokenMap { | |
| if tokenData.Name == tokenName { | |
| // make sure that the token is compatible with our rebalance method | |
| tokenMethod, tokenErr := cfg.GetRebalanceMethod(tokenData.ChainID, tokenData.Addr.Hex()) | |
| if tokenErr != nil { | |
| logger.Errorf("could not get token rebalance method for token %s: %v", tokenData.Addr.Hex(), tokenErr) | |
| continue | |
| } | |
| if tokenMethod != method { | |
| continue | |
| } | |
| // assign origin / dest metadata based on min / max balances | |
| if originTokenData == nil || tokenData.Balance.Cmp(originTokenData.Balance) > 0 { | |
| originTokenData = tokenData | |
| } | |
| if destTokenData == nil || tokenData.Balance.Cmp(destTokenData.Balance) < 0 { | |
| destTokenData = tokenData | |
| } | |
| } | |
| } | |
| } | |
| return originTokenData, destTokenData | |
| } |
Comment on lines
+124
to
+213
| // getRebalanceAmount calculates the amount to rebalance based on the configured thresholds. | ||
| // | ||
| //nolint:cyclop,nilnil | ||
| func getRebalanceAmount(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, originTokenData, destTokenData *TokenMetadata) (amount *big.Int, err error) { | ||
| // get the maintenance and initial values for the destination chain | ||
| maintenancePct, err := cfg.GetMaintenanceBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | ||
| } | ||
| initialPct, err := cfg.GetInitialBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("could not get initial pct: %w", err) | ||
| } | ||
|
|
||
| // calculate maintenance threshold relative to total balance | ||
| tokenName := originTokenData.Name | ||
| totalBalance := big.NewInt(0) | ||
| for _, tokenMap := range tokens { | ||
| for _, tokenData := range tokenMap { | ||
| if tokenData.Name == tokenName { | ||
| 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", 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())) | ||
| } | ||
|
|
||
| // no need to rebalance if we are not below maintenance threshold on destination | ||
| if destTokenData.Balance.Cmp(maintenanceThresh) > 0 { | ||
| return nil, nil | ||
| } | ||
|
|
||
| // calculate the amount to rebalance vs the initial threshold on destination | ||
| initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil) | ||
| 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 { | ||
| //nolint:nilnil | ||
| return nil, nil | ||
| } | ||
|
|
||
| // filter the rebalance amount by the configured min | ||
| 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(originTokenData.ChainID, originTokenData.Addr) | ||
| if amount.Cmp(maxAmount) > 0 { | ||
| amount = maxAmount | ||
| } | ||
| if span != nil { | ||
| span.SetAttributes( | ||
| attribute.String("initial_thresh", initialThresh.String()), | ||
| attribute.String("rebalance_amount", amount.String()), | ||
| attribute.String("max_rebalance_amount", maxAmount.String()), | ||
| ) | ||
| } | ||
|
|
||
| // make sure that the rebalance amount does not take origin below maintenance threshold | ||
| maintenancePctOrigin, err := cfg.GetMaintenanceBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex()) | ||
| if err != nil { | ||
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | ||
| } | ||
| maintenanceThreshOrigin, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePctOrigin/100)).Int(nil) | ||
| newBalanceOrigin := new(big.Int).Sub(originTokenData.Balance, amount) | ||
| if newBalanceOrigin.Cmp(maintenanceThreshOrigin) < 0 { | ||
| if span != nil { | ||
| span.SetAttributes( | ||
| attribute.Float64("maintenance_pct_origin", maintenancePctOrigin), | ||
| attribute.String("maintenance_thresh_origin", maintenanceThreshOrigin.String()), | ||
| attribute.String("new_balance_origin", newBalanceOrigin.String()), | ||
| ) | ||
| } | ||
| return nil, nil | ||
| } | ||
|
|
||
| return amount, nil | ||
| } |
There was a problem hiding this comment.
Optimize the getRebalanceAmount function by ensuring that calculations and conditional checks are efficient and correctly implemented.
- maintenanceThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil)
+ maintenanceThresh, err := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil)
+ if err != nil {
+ return nil, fmt.Errorf("error calculating maintenance threshold: %w", err)
+ }Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation.
Suggested change
| // getRebalanceAmount calculates the amount to rebalance based on the configured thresholds. | |
| // | |
| //nolint:cyclop,nilnil | |
| func getRebalanceAmount(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, originTokenData, destTokenData *TokenMetadata) (amount *big.Int, err error) { | |
| // get the maintenance and initial values for the destination chain | |
| maintenancePct, err := cfg.GetMaintenanceBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| initialPct, err := cfg.GetInitialBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get initial pct: %w", err) | |
| } | |
| // calculate maintenance threshold relative to total balance | |
| tokenName := originTokenData.Name | |
| totalBalance := big.NewInt(0) | |
| for _, tokenMap := range tokens { | |
| for _, tokenData := range tokenMap { | |
| if tokenData.Name == tokenName { | |
| 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", 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())) | |
| } | |
| // no need to rebalance if we are not below maintenance threshold on destination | |
| if destTokenData.Balance.Cmp(maintenanceThresh) > 0 { | |
| return nil, nil | |
| } | |
| // calculate the amount to rebalance vs the initial threshold on destination | |
| initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil) | |
| 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 { | |
| //nolint:nilnil | |
| return nil, nil | |
| } | |
| // filter the rebalance amount by the configured min | |
| 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(originTokenData.ChainID, originTokenData.Addr) | |
| if amount.Cmp(maxAmount) > 0 { | |
| amount = maxAmount | |
| } | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.String("initial_thresh", initialThresh.String()), | |
| attribute.String("rebalance_amount", amount.String()), | |
| attribute.String("max_rebalance_amount", maxAmount.String()), | |
| ) | |
| } | |
| // make sure that the rebalance amount does not take origin below maintenance threshold | |
| maintenancePctOrigin, err := cfg.GetMaintenanceBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| maintenanceThreshOrigin, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePctOrigin/100)).Int(nil) | |
| newBalanceOrigin := new(big.Int).Sub(originTokenData.Balance, amount) | |
| if newBalanceOrigin.Cmp(maintenanceThreshOrigin) < 0 { | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.Float64("maintenance_pct_origin", maintenancePctOrigin), | |
| attribute.String("maintenance_thresh_origin", maintenanceThreshOrigin.String()), | |
| attribute.String("new_balance_origin", newBalanceOrigin.String()), | |
| ) | |
| } | |
| return nil, nil | |
| } | |
| return amount, nil | |
| } | |
| // getRebalanceAmount calculates the amount to rebalance based on the configured thresholds. | |
| // | |
| //nolint:cyclop,nilnil | |
| func getRebalanceAmount(span trace.Span, cfg relconfig.Config, tokens map[int]map[common.Address]*TokenMetadata, originTokenData, destTokenData *TokenMetadata) (amount *big.Int, err error) { | |
| // get the maintenance and initial values for the destination chain | |
| maintenancePct, err := cfg.GetMaintenanceBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| initialPct, err := cfg.GetInitialBalancePct(destTokenData.ChainID, destTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get initial pct: %w", err) | |
| } | |
| // calculate maintenance threshold relative to total balance | |
| tokenName := originTokenData.Name | |
| totalBalance := big.NewInt(0) | |
| for _, tokenMap := range tokens { | |
| for _, tokenData := range tokenMap { | |
| if tokenData.Name == tokenName { | |
| totalBalance.Add(totalBalance, tokenData.Balance) | |
| } | |
| } | |
| } | |
| maintenanceThresh, err := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePct/100)).Int(nil) | |
| if err != nil { | |
| return nil, fmt.Errorf("error calculating maintenance threshold: %w", err) | |
| } | |
| if span != nil { | |
| span.SetAttributes(attribute.Float64("maintenance_pct", maintenancePct)) | |
| span.SetAttributes(attribute.Float64("initial_pct", initialPct)) | |
| 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())) | |
| } | |
| // no need to rebalance if we are not below maintenance threshold on destination | |
| if destTokenData.Balance.Cmp(maintenanceThresh) > 0 { | |
| return nil, nil | |
| } | |
| // calculate the amount to rebalance vs the initial threshold on destination | |
| initialThresh, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(initialPct/100)).Int(nil) | |
| 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 { | |
| //nolint:nilnil | |
| return nil, nil | |
| } | |
| // filter the rebalance amount by the configured min | |
| 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(originTokenData.ChainID, originTokenData.Addr) | |
| if amount.Cmp(maxAmount) > 0 { | |
| amount = maxAmount | |
| } | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.String("initial_thresh", initialThresh.String()), | |
| attribute.String("rebalance_amount", amount.String()), | |
| attribute.String("max_rebalance_amount", maxAmount.String()), | |
| ) | |
| } | |
| // make sure that the rebalance amount does not take origin below maintenance threshold | |
| maintenancePctOrigin, err := cfg.GetMaintenanceBalancePct(originTokenData.ChainID, originTokenData.Addr.Hex()) | |
| if err != nil { | |
| return nil, fmt.Errorf("could not get maintenance pct: %w", err) | |
| } | |
| maintenanceThreshOrigin, _ := new(big.Float).Mul(new(big.Float).SetInt(totalBalance), big.NewFloat(maintenancePctOrigin/100)).Int(nil) | |
| newBalanceOrigin := new(big.Int).Sub(originTokenData.Balance, amount) | |
| if newBalanceOrigin.Cmp(maintenanceThreshOrigin) < 0 { | |
| if span != nil { | |
| span.SetAttributes( | |
| attribute.Float64("maintenance_pct_origin", maintenancePctOrigin), | |
| attribute.String("maintenance_thresh_origin", maintenanceThreshOrigin.String()), | |
| attribute.String("new_balance_origin", newBalanceOrigin.String()), | |
| ) | |
| } | |
| return nil, nil | |
| } | |
| return amount, nil | |
| } |
Defi-Moses
added a commit
that referenced
this pull request
May 31, 2024
* Update bl * chore: lint bl * RFQ: support multiple rebalance methods (#2556) * WIP: refactor GetRebalanceMethod() * Feat: implement more robust rebalance method handling * Feat: move method validation to getRebalance() func * Feat: manual impl for String() on RebalanceMethod * Fix: tests * Feat: add rebalance method clauses to TestGetRebalance * Feat: use rebalance.Method to choose executor * Cleanup: lint * [goreleaser] * [goreleaser] * RFQ: drop requests for unsupported chains (#2563) * Feat: check for unsupported chain in inventory manager * Cleanup: lint * [goreleaser] * Fix: check for nil base fee * [goreleaser] * Feat: fee pricer gets gas price from SuggestGasPrice() * [goreleaser] * Fix: tests * lint, add err around clientSuggestGasPrice * Fix: tests --------- Co-authored-by: aureliusbtc <[email protected]> * RFQ: add decimals cache (#2502) * Feat: add decimalsCache, refactor decimal fetching * Cleanup: comments * Fix: build * Fix: use concurrent map * CCTP: use chain listener instead of scribe (#2592) * WIP: replace scribe with chain listener * Fix: build * Fix: tests * Fix: rfq build * Cleanup: remove unused enum * Cleanup: revert test change * Cleanup: comments * Cleanup: lint * Fix: build * Fix: test * docs(contracts-communication): move natspec from interfaces (#2595) * docs: SynapseExecutionServiceV1 * docs: SynapseGasOracleV1 * docs: Interchain app templates * docs: InterchainClientV1 * docs: InterchainDB * docs: interchain modules * docs: MessageBus * style: make interfaces easier to read * chore: fix linter warnings * Publish - [email protected] * fix(sdk-rouder): remove cache hydration (#2597) * fix: disable hydration * chore: don't log quotes in the integration test * Publish - @synapsecns/[email protected] - @synapsecns/[email protected] - @synapsecns/[email protected] - @synapsecns/[email protected] * update bl * Revert "update bl" This reverts commit ab56c7a. * update bl * feat(webhook): add webhook (#2538) * add models and endpoint, lacking logic * just stuff * just stuff * made general db interface * cleanup * trying to test * trying to test * trying ot fix test * remove interface{} from gorm models, start tests, rework db interface * add signature * secret * look away for now * finish db test * finish tests * add auth * remove debugging log * comments and nits * lint * appsecret and appid * resolve comments * swagger, lint * feat(synapse-interface): maintenance aggregator using PAUSED_CHAINS (#2345) * Aggregate maintenance events for banners and warning message * Dynamically render countdown progress bars based on PAUSED_CHAIN * Dynamically rendering banners * Slightly organize * ChainPause type applied to enforce maintenance event structure, pass in component messages as a prop * Working with multiple events * Add dev comments to MaintenanceBanner; refactor * Add dev comments for MaintenanceWarningMessage; refactor * Dev comments * Organize components * isChainIncluded util * Clean * Add ability to specify paused chains by from/to side (#2346) * Allow indefinite maintenance components by setting end date to null * Banners to show indefinitely as well * Add props to disable banner / warning / countdown * Implement disable warning * Implement disable countdown, bridge pause still working * Example * Clean * Update naming on Bridge page * Update comment for isChainIncluded * Create maintenance events reading from pausedChains.json * Remove custom margins to allow Bridge parent gap styling to handle spacing * Require all props to be defined * Add Swap to maintenance warning messages * Update useMaintenanceCountdownProgresses to allow distinction between Swap and Bridge pauses * Move MaintenanceBanners into LandingPageWrapper so banner appears on all pages * Add ability to specify whether to pause bridge / swap with maintenance event in json * Clean * Unused code * Update dev comments * Update pause start/end time name for legibility * Create type guard to check for paused bridge module * usePausedBridgeModules * usePausedBridgeModules to filter out SDK quotes * Initialize paused routes to handle specific route pauses instead of grouping with chain pauses * Update paused route structure * Filter for valid quotes based on paused routes * Create a Set with paused bridge module names to improve time complexity * Allow for all bridge modules to be paused with ALL * Add ability to pause bridge modules for all chains, if chainId is left undefined * Move json files to /v1/ version control folder * Compare quotes against paused bridge modules more cleanly * Paused bridge modules json control working * Fix pausedChains json * Create examples folder for pause jsons * Retrigger build * Fix banner flashing after clearing * Add padding to banner Close button * Update text sizing on progress bar * Update prop naming to prevent confusion on start/end * Clear chain pauses to ready PR * Change json file naming to be more readable * Use inputWarningMessage prop name to indicate warning placement * Pause Doge activity using Maintenance, to replace prior Chain pause mechanism * Doge chain paused chain prop values * Remove paused from/to chainId constants * Publish - @synapsecns/[email protected] * Exempt gh pages (#2541) Co-authored-by: Trajan0x <[email protected]> * Deploy: `FastBridge` to Scroll (#2525) * chore: add Base to `.env.example` * chore: add Scroll config * chore: bump devops dependency * chore: yarn * feat: deploy `FastBridge` on scroll * Publish - [email protected] * fix: update `forge-std` to 1.8.1, remove `ds-test`, use `solhint` for linting (#2545) * chore: forge-std v1.8.1, remove ds-test dep * chore: remove ds-test from remappings * refactor: state mutability * chore: add solhint * chore: yarn * fix: unused imports * fix: max line length * Publish - [email protected] - [email protected] - @synapsecns/[email protected] * chore: remove submodules from `contracts-rfq` (#2547) * build: install OZ as npm module * chore: update remappings * refactor: fix compiler warnings in test contract * chore: remove forge-std submodule * chore: remove `openzeppelin-contracts` submodule * fix: restore padding in `.gitmodules` * Publish - [email protected] * gogenerate * Revert "gogenerate" This reverts commit b40e602. * im dumb * generate * tidy * update swagger doc * [goreleaser] * [goreleaser] --------- Co-authored-by: shampoobera <[email protected]> Co-authored-by: bigboydiamonds <[email protected]> Co-authored-by: bigboydiamonds <[email protected]> Co-authored-by: trajan0x <[email protected]> Co-authored-by: Trajan0x <[email protected]> Co-authored-by: χ² <[email protected]> Co-authored-by: ChiTimesChi <[email protected]> * rfq api cache (#2562) * cache api result [goreleaser] * clean up * clean up 2 --------- Co-authored-by: Trajan0x <[email protected]> * add trace to sync (#2601) * trace more * cleanup * allow use of mustache templates --------- Co-authored-by: Trajan0x <[email protected]> * remove iconfig file (#2602) Co-authored-by: Trajan0x <[email protected]> * feat(contracts-communication): remove batching (#2599) * feat: scaffold InterchainDB interface changes * feat: scaffold Module interface changes * feat: update InterchainEntry * test: update DB tests * test: update Client tests * refactor: ModuleBatch -> ModuleEntry * feat: remove `entryIndex` from InterchainTx * feat: scaffold Client interface changes * feat: start updating the Module * test: update integration tests * cleanup: remove BatchingV1 * feat: update InterchainDB * cleanup: remove entryIndex from apps * cleanup: remove entryIndex from Client events * feat: update ClientV1 * cleanup: remove entryIndex from DB * test: update SynapseModule tests * cleanup: ClientV1 * cleanup: DB * cleanup: Module * cleanup: remove batch lib * docs: smol fixes * Publish - [email protected] * optional screener for cctp relayer (#2600) Co-authored-by: Trajan0x <[email protected]> * Sin/testnet 9 (#2567) * fix: remove `ExecutionFees` references * New set of deployments * Adjust config files to the latest changes * adding spectral coingecko ids for pricing (#2596) * feat(widget): suppress console errors (#2594) * Allow widget to suppress Synapse console errors * feat(sdk-router): router cache error log (#2591) * Improve RouterCache error logging * Add common error string to target at Consumer level * Add common string to all console errors * feat(widget): error logs (#2593) * Add common base string to allow hiding Widget related errors outputted in Consumer app * Convert logs into errors if firing in catch statement * Update README * Optional prop * Switch catch log to error * Re-trigger action * Remove line * Publish - @synapsecns/[email protected] - @synapsecns/[email protected] - @synapsecns/[email protected] - @synapsecns/[email protected] * fix(contracts-communication): interchain module ignore nonces (#2604) * feat: remove dbNonce from Module interface * cleanup: update Module interface references * refactor: lint * Publish - [email protected] * feat(synapse-interface): bridge gas handler (#2437) * Initial gas data slice state * Async thunk fetchGasData * Add gas data reducers * useFetchGasDataOnInterval added to Bridge Listener * Explicitly declare fetching gas data in gwei * Calculate max bridgeable amount * On max balance factoring in gas cost * Add comment * Differentiate max balance vs max bridgeable balance * Add error toaster for when max balance less than bridge fee * refactor; calculateGasFeeInGwei() * Move to util * Fix lint error * Fetch gas when fromChainId on bridge card changes * Use exact token balance when calculate max bridgeable amount * Conditions for showing max button * showMaxOption to determine display * Disable max button if gas fees more than gas balance * Clean jsx * AvailableBalance component to track subscript detail in bridge origin input * Return raw and formatted gas cost in calculateGasCost * Update comments * Fix imports based on name cange * Use parsed * calculateMaxBridgeableGas * Clean * refactor: clean InputContainer * Replace onMaxBalance() with onMaxBridgeableBalance()` * Allow undefined object when destructuring * Display when token balance is trace balance * Typing * showGasReserved * Update avail balance text and color when gas cost greater than balance * Detect when input value is less than required estimated gas * onAvailableBalance applied * Make opacity greater when Max button disabled * Fix calculations for when gas input is enough to cover gas * Clean * Add hover tooltip for warning gas states * Use tooltip to describe gas status * Update tooltip text * Add buffer to calculate gas cost, use 1.5x * AvailableBalance component to replace label in AmountInput * Display trace balances in AvailableBalance * Fix naming * Add HoverTooltip to Available Balance * Add conditions for displaying gas error based on input * Use full parsed balance when making comparisons for gas checks * Show gas reserved in Available Balance * hasOnlyZeroes to return true if string contains only zeroes and periods * Display estimated gas cost in tool tip * Remove Available Balance elements from AmountInput, migrated to AvailableBalance * Display trace amount for input when displaying how much is reserved for gas * Fetch estimated gas limit based on real bridge quote using max gas balance * Fetching accurate gasLimit * Fix Trace balance * Set gasLimit to 0 if not valid bridge data avail * ... * Fix when gas covered msg appears * Available Balance * Clean available balance flow * useGasEstimator hook to encapsulate logic to clean InputContainer * Fix prop issue * Remove duplicate HoverTooltip * Move HoverTooltip to shared component folder * Update gas fetch for wagmi v2, up limit to 1.7 * Estimated gas bridge quote fetched on load * Update var naming * Improve Available Balance flow * Display estimated bridgeable balance on hover * Show gas estimate when estimated gas cost available * Do not show negative bridgable balance * Separate out bridge gas limit calculations into smaller functions * Wrap async functions with try catch * Implement updated gas estimation flow * Move gas estimate logic to useGasEstimator * Move async sdk fetch functions to useGasEstimator file * Remove unused vars * Shorten est gas cost * Improve code legibility in AvailableBalance * Assign conditions to vars to reduce clutter * Reset gas price data when fromChainId changes * Reset fetched gas limit when fromChainId changes * Clean * Fix old import * Fix max button placement * Add loading state for useGasEstimator * Remove available balance states for gas est * Remove unused props * Clean gas token detection in PortfolioTokenAsset * Simplify onMaxBalance() * Clean constants in InputContainer * Clean token detail destructuring * Include gas estimate when updating input from Portfolio token selection * Fire error toaster if gas fees exceed balance * Render error toaster when firing onMaxBalance callback instead of a side effect * Clean useGasEstimator * Ensure available balance does not show if wallet not connected, set default value if balances not loaded * Replicate onMax behavior in Portfolio * Use fetched gas * Improve error handling in gas estimator * ... * Remove tooltip on AvailableBalance * Remove balance prefill from Portfolio Token selection * Update available balance in input based on max bridgeable gas toke * Destructure estimateGasLimit callback from useGasEstimator to retrigger fetching gas estimate * Refetch gas ata in estimateGasLimit callback * Display total vs bridgeable balance on hover in Portfolio gas token when gas data available * Update balance shown on hover * Clean * Simplify useFetchGasDataOnInterval * Prevent unnecessary fetches, fix chain update old gas issue * Fetch estimated bridgeable max gas amount onClick token max input, fill input once amount fetched * Clean * onMaxBalance will use default balanceif fetched bridgeable balance estimate returns null * Show dust gas amounts on hover in Portfolio * Clean * Available balance including gas estimates moved to within Input to synchronize data * Move gasLimit to global store to share data between Bridge components * Display max bridgeable balance on hover in Portfolio, add onMaxBalance onClick Portfolio asset * Portfolio and Input available balance onClick behave the same * Fetch gas prices to provide most accurate gas cost * Remove hover on AvailableBalance * Fix Token Selector width * Remove onClick Portfolio Token Balance, allow Token selection from Portfolio only without Balance input update * Cursor default on Portfolio Token Balance * Show available/max buttons when bridge valid selections * Swap input to have available balance * Clean * Basic MaxButton onClick and hidden when loading gas data * Show MaxButton when input is not full balance or bridgeable balance * Implement Max button and placement in Bridge/Swap * Hide MaxButton until connected * Hide MaxButton conditions * Show Max when all input selections are made * Remove click states for AvailableBalance on Bridge/Swap * Style Input / Max * Max mobile size * Fe/format amount (#2598) * formatAmount util function, use rounded shortened values in Bridge/Swap Input * Update Bridge/Swap page with parsed / formatted balances * Clean imports * Clean imports * Swap Max spacing * Improve html element composition * Prevent layout shift in Swap UI * Publish - @synapsecns/[email protected] * add "and" (#2608) * fix(contracts-communication): default settings for Guard service (#2605) * test: should ignore optimistic period w/o guard * test: app should have empty config be default * test: should allow setting zero optimistic period * fix: ignore optimistic period without a guard * fix: use GUARD_DISABLED flag by default * fix: don't revert on zero optimistic period * test: different optimistic periods for integration tests * fix: use default guard for PingPongApp * refactor: fix linter warnings * Publish - [email protected] - @synapsecns/[email protected] * Fix: put blocking call to Start() in new goroutine (#2614) * feat(contracts-communication): default values for modules/required respones (#2612) * feat: scaffold defaultModule in Client * test: expected behavior for setting default module * feat: setting default Module in Client * refactor: Client views test * test: appConfig with zero modules/responses * feat: module config defaults * cleanup: remove `ZeroRequiredResponses` error * refactor: prep for 0 and 1 module tests * test: ClientV1 + app with 1 module * test: ClientV1 + app with 0 modules * Publish - [email protected] * RFQ: rebalance edge cases & refactoring (#2613) * Fix: filter rebalance origin / dest on rebalance method * Cleanup: move getRebalance() into rebalance.go * Cleanup: add helpers to getRebalance() * Cleanup: comments * Feat: remove Rebalance() call upon deposit claimed * Feat: getRebalance() takes in dest chain id * Cleanup: comments * Feat: extra check that we don't exceed origin maintenance * Feat: add new test case for mismatched methods but existing rebalance * Feat: break down TestGetRebalance into sub tests * Cleanup: lint * [goreleaser] * [goreleaser] * refactor: move opinionated stuff into SynapseModule (#2617) * Publish - [email protected] * Document Modules (#2611) Co-authored-by: Trajan0x <[email protected]> * cleanup (#2618) Co-authored-by: Trajan0x <[email protected]> * fix tests (#2620) Co-authored-by: Trajan0x <[email protected]> * RFQ API: replace `otelresty` with `otelhhtp` package (#2606) * Feat: replace otelresty usage with otelhttp pkg * [goreleaser] * make coverage aggregator public (#2621) Co-authored-by: Trajan0x <[email protected]> * Publish - @synapsecns/[email protected] * publish aggregator fix (#2622) Co-authored-by: Trajan0x <[email protected]> * Publish - @synapsecns/[email protected] * fix(solidity-devops): update forge-std to 1.8.2 (#2619) * build: update `forge-std` to 1.8.2 * chore: yarn * Publish - [email protected] - [email protected] - @synapsecns/[email protected] * feat(docs): auto deploy vercel to prod (only vercel) (#2627) Co-authored-by: Trajan0x <[email protected]> * fix(ci): fixes bug in #2627, deploys go to prod (#2628) Co-authored-by: Trajan0x <[email protected]> * docs(contributing) add a guide on adding js packages (#2629) * docs(contributing) add a guide on adding js packages * Update CONTRIBUTING.md Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --------- Co-authored-by: Trajan0x <[email protected]> Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * revert coderabbit fix (#2630) Co-authored-by: Trajan0x <[email protected]> * prod release fix (#2631) Co-authored-by: Trajan0x <[email protected]> * Publish - @synapsecns/[email protected] * add grafana dashboard and fix broken link (#2634) Co-authored-by: Trajan0x <[email protected]> * add scroll (#2635) Co-authored-by: Trajan0x <[email protected]> * Submitter: bump MaxResultsPerChain (#2633) * Feat: bump MaxResultsPerChain * [goreleaser] * fast bridge regen (#2636) Co-authored-by: Trajan0x <[email protected]> * omnirpc doc fixes (#2637) * swagger * embed swagger ui * generic lint fixer --------- Co-authored-by: Trajan0x <[email protected]> * fix typo (#2638) Co-authored-by: Trajan0x <[email protected]> * Update bl * Add SPECTRAL token support (#2640) * Publish - @synapsecns/[email protected] - @synapsecns/[email protected] * feat(synapse-interface): Adds Scroll via RFQ (#2526) * Adds Scroll via RFQ * Adds NewTag * Adds RFQ logic into the generateMaps script * Adds announcement banner * Linting * Adjusts order * API call for quotes * Updates bridgeMap for live Scroll quotes * For reusing NewTag * Adjust dates * Publish - @synapsecns/[email protected] * feat(widget): maintenance (#2616) * Fetch pause data and store JSON object in client browser * Refetch only if last fetch was more than 24 hours ago * Read chain + module pause from local storage * Maintenance components rendering based off of fetched pause data * Pause Bridge button based on Maintenance status * Filter quotes based on paused modules * Use user defined styling or defaults * Style Progress Bar * Refactor getSynapsePauseData * Clean * Fix bridge quote filter * Adjust text size for maintenance * Add comments + clean * Update comment * Refresh data every hour * Clean * Add key to warning messages * Fix render issues, start move event countdown component directly to Widget to resolve hooks issue * Resolve hooks render issue with localized component * Progress bar renders when not isabled * Clean and simplify Maintenance components * getMaintenanceData * Organize back into useMaintenance hook * Clean / organize * Use prod urls * Organizational updates * Fetch pause data every render, set fetching status flag * Rm timestamp key --------- Co-authored-by: abtestingalpha <[email protected]> * Publish - @synapsecns/[email protected] * RFQ API: add GET /ack endpoint (#2643) * WIP: add relay ack cache and GetRelayAck endpoint * Feat: register AckRoute * Feat: add ackMux * Feat: add GetRelayAck test * Feat: add GetRelayAck to UnauthenticatedClient * Feat: relayer fetches ack before updating to CommittedPending * [goreleaser] * Feat: move GET /ack to PUT /ack * WIP: generalize AuthMiddleware() * Fix: working refactor for auth * Feat: add PutAckRequest and parse in auth middleware * Feat: impl PUT /ack request with json req body * Feat: bump default timeout from 5 to 10 * Feat: add swagger comments * Cleanup: pass API client into quoter * Feat: return RelayerAddress in PutRelayAckResponse * Cleanup: add clarifying comment * [goreleaser] * Cleanup: lint * [goreleaser] * Cleanup: add tracing * [goreleaser] * Config: bump relay ack timeout to 30 seconds * [goreleaser] * Feat: lower submitter retry interval (#2645) * update bl * Adjusts banner date (#2647) * Publish - @synapsecns/[email protected] * Add SPEC token pricing to the manual cache (#2646) * adding spectral coingecko ids for pricing * adding spec token to cache * Update bl * fix(screener): fix screener http 502 (#2650) Co-authored-by: trajan0x <[email protected]> Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> * update bl * update bl --------- Co-authored-by: aureliusbtc <[email protected]> Co-authored-by: ChiTimesChi <[email protected]> Co-authored-by: dwasse <[email protected]> Co-authored-by: ChiTimesChi <[email protected]> Co-authored-by: Trajan0x <[email protected]> Co-authored-by: vro <[email protected]> Co-authored-by: shampoobera <[email protected]> Co-authored-by: bigboydiamonds <[email protected]> Co-authored-by: bigboydiamonds <[email protected]> Co-authored-by: trajan0x <[email protected]> Co-authored-by: Moses <[email protected]> Co-authored-by: Simon <[email protected]> Co-authored-by: aureliusbtc <[email protected]> Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> Co-authored-by: abtestingalpha <[email protected]>
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Summary by CodeRabbit
New Features
Refactor
Documentation