status-go/protocol/communities/permissioned_balances.go

package communities

import (
	"context"
	"math/big"
	"strconv"

	"github.com/pkg/errors"

	gethcommon "github.com/ethereum/go-ethereum/common"
	"github.com/status-im/status-go/eth-node/types"
	"github.com/status-im/status-go/protocol/protobuf"
	"github.com/status-im/status-go/services/wallet/bigint"
	"github.com/status-im/status-go/services/wallet/thirdparty"
)

type PermissionedBalance struct {
	Type     protobuf.CommunityTokenType `json:"type"`
	Symbol   string                      `json:"symbol"`
	Name     string                      `json:"name"`
	Amount   *bigint.BigInt              `json:"amount"`
	Decimals uint64                      `json:"decimals"`
}

func calculatePermissionedBalancesERC20(
	accountAddresses []gethcommon.Address,
	balances BalancesByChain,
	tokenPermissions []*CommunityTokenPermission,
) map[gethcommon.Address]map[string]*PermissionedBalance {
	res := make(map[gethcommon.Address]map[string]*PermissionedBalance)

	// Set with composite key (chain ID + wallet address + contract address) to
	// store if we already processed the balance.
	usedBalances := make(map[string]bool)

	for _, permission := range tokenPermissions {
		for _, criteria := range permission.TokenCriteria {
			if criteria.Type != protobuf.CommunityTokenType_ERC20 {
				continue
			}

			for _, accountAddress := range accountAddresses {
				for chainID, hexContractAddress := range criteria.ContractAddresses {
					usedKey := strconv.FormatUint(chainID, 10) + "-" + accountAddress.Hex() + "-" + hexContractAddress

					if _, ok := balances[chainID]; !ok {
						continue
					}
					if _, ok := balances[chainID][accountAddress]; !ok {
						continue
					}

					contractAddress := gethcommon.HexToAddress(hexContractAddress)
					value, ok := balances[chainID][accountAddress][contractAddress]
					if !ok {
						continue
					}

					// Skip the contract address if it has been used already in the sum.
					if _, ok := usedBalances[usedKey]; ok {
						continue
					}

					if _, ok := res[accountAddress]; !ok {
						res[accountAddress] = make(map[string]*PermissionedBalance, 0)
					}
					if _, ok := res[accountAddress][criteria.Symbol]; !ok {
						res[accountAddress][criteria.Symbol] = &PermissionedBalance{
							Type:     criteria.Type,
							Symbol:   criteria.Symbol,
							Name:     criteria.Name,
							Decimals: criteria.Decimals,
							Amount:   &bigint.BigInt{Int: big.NewInt(0)},
						}
					}

					res[accountAddress][criteria.Symbol].Amount.Add(
						res[accountAddress][criteria.Symbol].Amount.Int,
						value.ToInt(),
					)
					usedBalances[usedKey] = true
				}
			}
		}
	}

	return res
}

func isERC721CriteriaSatisfied(tokenBalances []thirdparty.TokenBalance, criteria *protobuf.TokenCriteria) bool {
	// No token IDs to compare against, so the criteria is satisfied.
	if len(criteria.TokenIds) == 0 {
		return true
	}

	for _, tokenID := range criteria.TokenIds {
		tokenIDBigInt := new(big.Int).SetUint64(tokenID)
		for _, asset := range tokenBalances {
			if asset.TokenID.Cmp(tokenIDBigInt) == 0 && asset.Balance.Sign() > 0 {
				return true
			}
		}
	}

	return false
}

func (m *Manager) calculatePermissionedBalancesERC721(
	accountAddresses []gethcommon.Address,
	balances CollectiblesByChain,
	tokenPermissions []*CommunityTokenPermission,
) map[gethcommon.Address]map[string]*PermissionedBalance {
	res := make(map[gethcommon.Address]map[string]*PermissionedBalance)

	// Set with composite key (chain ID + wallet address + contract address) to
	// store if we already processed the balance.
	usedBalances := make(map[string]bool)

	for _, permission := range tokenPermissions {
		for _, criteria := range permission.TokenCriteria {
			if criteria.Type != protobuf.CommunityTokenType_ERC721 {
				continue
			}

			for _, accountAddress := range accountAddresses {
				for chainID, hexContractAddress := range criteria.ContractAddresses {
					usedKey := strconv.FormatUint(chainID, 10) + "-" + accountAddress.Hex() + "-" + hexContractAddress

					if _, ok := balances[chainID]; !ok {
						continue
					}
					if _, ok := balances[chainID][accountAddress]; !ok {
						continue
					}

					contractAddress := gethcommon.HexToAddress(hexContractAddress)
					tokenBalances, ok := balances[chainID][accountAddress][contractAddress]
					if !ok || len(tokenBalances) == 0 {
						continue
					}

					// Skip the contract address if it has been used already in the sum.
					if _, ok := usedBalances[usedKey]; ok {
						continue
					}

					usedBalances[usedKey] = true

					if _, ok := res[accountAddress]; !ok {
						res[accountAddress] = make(map[string]*PermissionedBalance, 0)
					}
					if _, ok := res[accountAddress][criteria.Symbol]; !ok {
						res[accountAddress][criteria.Symbol] = &PermissionedBalance{
							Type:     criteria.Type,
							Symbol:   criteria.Symbol,
							Name:     criteria.Name,
							Decimals: criteria.Decimals,
							Amount:   &bigint.BigInt{Int: big.NewInt(0)},
						}
					}

					if isERC721CriteriaSatisfied(tokenBalances, criteria) {
						// We don't care about summing balances, thus setting as 1 is
						// sufficient.
						res[accountAddress][criteria.Symbol].Amount = &bigint.BigInt{Int: big.NewInt(1)}
					}
				}
			}
		}
	}

	return res
}

func (m *Manager) calculatePermissionedBalances(
	chainIDs []uint64,
	accountAddresses []gethcommon.Address,
	erc20Balances BalancesByChain,
	erc721Balances CollectiblesByChain,
	tokenPermissions []*CommunityTokenPermission,
) map[gethcommon.Address][]PermissionedBalance {
	res := make(map[gethcommon.Address][]PermissionedBalance, 0)

	aggregatedERC721Balances := m.calculatePermissionedBalancesERC721(accountAddresses, erc721Balances, tokenPermissions)
	for accountAddress, tokens := range aggregatedERC721Balances {
		for _, permissionedToken := range tokens {
			if permissionedToken.Amount.Sign() > 0 {
				res[accountAddress] = append(res[accountAddress], *permissionedToken)
			}
		}
	}

	aggregatedERC20Balances := calculatePermissionedBalancesERC20(accountAddresses, erc20Balances, tokenPermissions)
	for accountAddress, tokens := range aggregatedERC20Balances {
		for _, permissionedToken := range tokens {
			if permissionedToken.Amount.Sign() > 0 {
				res[accountAddress] = append(res[accountAddress], *permissionedToken)
			}
		}
	}

	return res
}

func keepRoleTokenPermissions(tokenPermissions map[string]*CommunityTokenPermission) []*CommunityTokenPermission {
	res := make([]*CommunityTokenPermission, 0)
	for _, p := range tokenPermissions {
		if p.Type == protobuf.CommunityTokenPermission_BECOME_MEMBER ||
			p.Type == protobuf.CommunityTokenPermission_BECOME_ADMIN ||
			p.Type == protobuf.CommunityTokenPermission_BECOME_TOKEN_MASTER ||
			p.Type == protobuf.CommunityTokenPermission_BECOME_TOKEN_OWNER {
			res = append(res, p)
		}
	}
	return res
}

// GetPermissionedBalances returns balances indexed by account address.
//
// It assumes balances in different chains with the same symbol can be summed.
// It also assumes the criteria's decimals field is the same across different
// criteria when they refer to the same asset (by symbol).
func (m *Manager) GetPermissionedBalances(
	ctx context.Context,
	communityID types.HexBytes,
	accountAddresses []gethcommon.Address,
) (map[gethcommon.Address][]PermissionedBalance, error) {
	community, err := m.GetByID(communityID)
	if err != nil {
		return nil, err
	}
	if community == nil {
		return nil, errors.Errorf("community does not exist ID='%s'", communityID)
	}

	tokenPermissions := keepRoleTokenPermissions(community.TokenPermissions())

	allChainIDs, err := m.tokenManager.GetAllChainIDs()
	if err != nil {
		return nil, err
	}
	accountsAndChainIDs := combineAddressesAndChainIDs(accountAddresses, allChainIDs)

	erc20TokenCriteriaByChain, erc721TokenCriteriaByChain, _ := ExtractTokenCriteria(tokenPermissions)

	accounts := make([]gethcommon.Address, 0, len(accountsAndChainIDs))
	for _, accountAndChainIDs := range accountsAndChainIDs {
		accounts = append(accounts, accountAndChainIDs.Address)
	}

	erc20ChainIDsSet := make(map[uint64]bool)
	erc20TokenAddresses := make([]gethcommon.Address, 0)
	for chainID, criterionByContractAddress := range erc20TokenCriteriaByChain {
		erc20ChainIDsSet[chainID] = true
		for contractAddress := range criterionByContractAddress {
			erc20TokenAddresses = append(erc20TokenAddresses, gethcommon.HexToAddress(contractAddress))
		}
	}

	erc721ChainIDsSet := make(map[uint64]bool)
	for chainID := range erc721TokenCriteriaByChain {
		erc721ChainIDsSet[chainID] = true
	}

	erc20ChainIDs := calculateChainIDsSet(accountsAndChainIDs, erc20ChainIDsSet)
	erc721ChainIDs := calculateChainIDsSet(accountsAndChainIDs, erc721ChainIDsSet)

	erc20Balances, err := m.tokenManager.GetBalancesByChain(ctx, accounts, erc20TokenAddresses, erc20ChainIDs)
	if err != nil {
		return nil, err
	}

	erc721Balances := make(CollectiblesByChain)
	if len(erc721ChainIDs) > 0 {
		balances, err := m.GetOwnedERC721Tokens(accounts, erc721TokenCriteriaByChain, erc721ChainIDs)
		if err != nil {
			return nil, err
		}

		erc721Balances = balances
	}

	return m.calculatePermissionedBalances(allChainIDs, accountAddresses, erc20Balances, erc721Balances, tokenPermissions), nil
}