feat: clean up balance fetching from token manager (#6991)

* feat: improvemets to multistandardbalance controller

* feat: introduce tokenbalances package

* chore: replace balance fetching capabilities from reader and token manager with tokenbalances

* feat: allow overriding multicall3 contract address

* chore: fix tests

* chore: pr comments

Author: dlipicar

api/defaults.go

@@ -201,6 +201,9 @@ func buildWalletConfig(walletRequest *requests.WalletConfig, request *requests.W
 	if walletRequest.MarketDataPriceRefreshInterval != 0 {
 		walletConfig.MarketDataProxyConfig.PriceRefreshInterval = walletRequest.MarketDataPriceRefreshInterval
 	}
+	if len(walletRequest.MulticallOverrides) > 0 {
+		walletConfig.MulticallOverrides = walletRequest.MulticallOverrides
+	}
 
 	if !request.StatusProxyUser.Empty() {
 		walletConfig.StatusProxyUser = request.StatusProxyUser

api/geth_backend.go

@@ -2348,7 +2348,7 @@ func (b *GethStatusBackend) initProtocol() error {
 		TimeSource:             b.statusNode.TimeSource(),
 		MetricsEnabled:         b.prometheusMetrics != nil,
 		TokenManager:           NewCommunitiesTokenManager(b.statusNode.TokenManager()),
-		TokenBalanceManager:    NewCommunitiesTokenBalanceManager(b.statusNode.TokenManager()),
+		TokenBalanceManager:    NewCommunitiesTokenBalanceManager(b.statusNode.TokenBalancesFetcher(), b.statusNode.TokenBalancesStorage()),
 		NetworkManager:         NewCommunitiesNetworkManager(b.statusNode.RPCClient().GetNetworkManager()),
 	}
 	err = st.InitProtocol(params)

api/protocol_adaptors.go

@@ -2,12 +2,16 @@ package api
 
 import (
 	"context"
+	"fmt"
+	"math/big"
 
 	gethcommon "github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/status-im/status-go/protocol/communities"
 	"github.com/status-im/status-go/rpc/network"
 	"github.com/status-im/status-go/services/wallet/token"
 	tokenTypes "github.com/status-im/status-go/services/wallet/token/types"
+	"github.com/status-im/status-go/services/wallet/tokenbalances"
 )
 
 var _ communities.NetworkManager = (*CommunitiesNetworkManager)(nil)
@@ -48,28 +52,52 @@ func (m *CommunitiesTokenManager) FindOrCreateTokenByAddress(ctx context.Context
 }
 
 type CommunitiesTokenBalanceManager struct {
-	tokenManager *token.Manager
+	tokenBalancesFetcher *tokenbalances.Fetcher
+	tokenBalancesStorage tokenbalances.Storage
 }
 
-func NewCommunitiesTokenBalanceManager(tm *token.Manager) *CommunitiesTokenBalanceManager {
-	return &CommunitiesTokenBalanceManager{tokenManager: tm}
+func NewCommunitiesTokenBalanceManager(f *tokenbalances.Fetcher, s tokenbalances.Storage) *CommunitiesTokenBalanceManager {
+	return &CommunitiesTokenBalanceManager{tokenBalancesFetcher: f, tokenBalancesStorage: s}
 }
 
 func (m *CommunitiesTokenBalanceManager) GetBalancesByChain(ctx context.Context, accounts, tokenAddresses []gethcommon.Address, chainIDs []uint64) (communities.BalancesByChain, error) {
-	chainClients, err := m.tokenManager.RPCClient.EthClients(chainIDs)
-	if err != nil {
-		return nil, err
+	if m.tokenBalancesFetcher == nil {
+		return nil, fmt.Errorf("tokenBalancesFetcher is nil")
 	}
-
-	resp, err := m.tokenManager.GetBalancesByChain(context.Background(), chainClients, accounts, tokenAddresses)
-	return resp, err
+	ret := make(communities.BalancesByChain)
+	for _, chainID := range chainIDs {
+		ret[chainID] = make(map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big)
+		balances, err := m.tokenBalancesFetcher.Fetch(ctx, chainID, tokenAddresses, accounts)
+		if err != nil {
+			return nil, err
+		}
+		ret[chainID] = balancesToCommunitiesBalances(balances)
+	}
+	return ret, nil
 }
 
 func (m *CommunitiesTokenBalanceManager) GetCachedBalancesByChain(ctx context.Context, accounts, tokenAddresses []gethcommon.Address, chainIDs []uint64) (communities.BalancesByChain, error) {
-	resp, err := m.tokenManager.GetCachedBalancesByChain(accounts, tokenAddresses, chainIDs)
-	if err != nil {
-		return resp, err
+	if m.tokenBalancesStorage == nil {
+		return nil, fmt.Errorf("tokenBalancesStorage is nil")
+	}
+	ret := make(communities.BalancesByChain)
+	for _, chainID := range chainIDs {
+		balances, err := m.tokenBalancesStorage.GetBalances(ctx, chainID, tokenAddresses, accounts)
+		if err != nil {
+			return nil, err
+		}
+		ret[chainID] = balancesToCommunitiesBalances(balances)
 	}
+	return ret, nil
+}
 
-	return resp, nil
+func balancesToCommunitiesBalances(balances map[gethcommon.Address]map[gethcommon.Address]*big.Int) map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big {
+	ret := make(map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big)
+	for account, tokenBalances := range balances {
+		ret[account] = make(map[gethcommon.Address]*hexutil.Big)
+		for token, balance := range tokenBalances {
+			ret[account][token] = (*hexutil.Big)(balance)
+		}
+	}
+	return ret
 }