synapsecns/sanguine

package exporters

import (
    "context"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/lmittmann/w3/module/eth"
    "github.com/lmittmann/w3/w3types"
    "github.com/synapsecns/sanguine/contrib/promexporter/internal/decoders"
    "github.com/synapsecns/sanguine/core"
    "github.com/synapsecns/sanguine/core/metrics"
    ethergoClient "github.com/synapsecns/sanguine/ethergo/client"
    "github.com/synapsecns/sanguine/services/explorer/contracts/bridgeconfig"
    "golang.org/x/sync/errgroup"
)

func (e *exporter) getAllTokens(parentCtx context.Context) (allTokens Tokens, err error) {
    allTokens = []TokenConfig{}

    ctx, span := e.metrics.Tracer().Start(parentCtx, "get_all_tokens")

    defer func() {
        metrics.EndSpanWithErr(span, err)
    }()

    bridgeConfig, err := e.getBridgeConfig(ctx)
    if err != nil {
        return nil, fmt.Errorf("could not get bridge config: %w", err)
    }

    // TODO: multicall is preferable here, but I ain't got time for that
    tokenIDs, err := bridgeConfig.GetAllTokenIDs(&bind.CallOpts{Context: ctx})
    if err != nil {
        return nil, fmt.Errorf("could not get all token ids: %w", err)
    }

    bridgeConfigClient, err := e.omnirpcClient.GetConfirmationsClient(ctx, e.cfg.BridgeConfig.ChainID, 1)
    if err != nil {
        return nil, fmt.Errorf("could not get confirmations client: %w", err)
    }

    bridgeTokens := make([]*bridgeconfig.BridgeConfigV3Token, len(tokenIDs)*len(e.cfg.BridgeChecks))

    //nolint: revive
    tokenIDS := make([]string, len(tokenIDs)*len(e.cfg.BridgeChecks))

    var calls []w3types.Caller

    i := 0
    for _, tokenID := range tokenIDs {
        for chainID := range e.cfg.BridgeChecks {
            token := &bridgeconfig.BridgeConfigV3Token{}
            calls = append(calls, eth.CallFunc(decoders.TokenConfigGetToken(), bridgeConfig.Address(), tokenID, big.NewInt(int64(chainID))).Returns(token))
            bridgeTokens[i] = token
            tokenIDS[i] = tokenID
            i++
        }
    }

    // TODO: once go 1.21 is introduced do min(cfg.BatchCallLimit, 2)
    err = e.batchCalls(ctx, bridgeConfigClient, calls)
    if err != nil {
        return nil, fmt.Errorf("could not get token balances: %w", err)
    }

    for i, token := range bridgeTokens {
        tokenID := tokenIDS[i]

        if token.TokenAddress == "" {
            continue
        }

        allTokens = append(allTokens, TokenConfig{
            TokenID:       tokenID,
            ChainID:       int(token.ChainId.Int64()),
            TokenAddress:  common.HexToAddress(token.TokenAddress),
            TokenDecimals: token.TokenDecimals,
            HasUnderlying: token.HasUnderlying,
            IsUnderlying:  token.IsUnderlying,
        })
    }

    return allTokens, nil
}

func (e *exporter) batchCalls(ctx context.Context, evmClient ethergoClient.EVM, calls []w3types.Caller) (err error) {
    tasks := core.ChunkSlice(calls, e.cfg.BatchCallLimit)

    g, ctx := errgroup.WithContext(ctx)
    for _, task := range tasks {
        task := task // capture func literal
        g.Go(func() error {
            err = evmClient.BatchWithContext(ctx, task...)
            if err != nil {
                return fmt.Errorf("could not batch calls: %w", err)
            }

            return nil
        })
    }

    err = g.Wait()
    if err != nil {
        return fmt.Errorf("could not get token balances: %w", err)
    }

    return nil
}

// Tokens is a list of token configs.
type Tokens []TokenConfig

// GetForChainID returns all tokens for a given chainID.
func (t Tokens) GetForChainID(chainID int) Tokens {
    var chainTokens []TokenConfig
    for _, token := range t {
        if token.ChainID == chainID {
            chainTokens = append(chainTokens, token)
        }
    }

    return chainTokens
}

// TokenConfig is a cleaned up token config.
type TokenConfig struct {
    TokenID       string
    ChainID       int
    TokenAddress  common.Address
    TokenDecimals uint8
    HasUnderlying bool
    IsUnderlying  bool
}