synapsecns/sanguine

package service

import (
    "context"
    "errors"
    "fmt"
    "strings"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
    "github.com/synapsecns/sanguine/services/rfq/contracts/ierc20"
    "github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
    "github.com/synapsecns/sanguine/services/rfq/util"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/trace"
    "golang.org/x/sync/errgroup"
)

// startChainIndexers starts the chain indexers for each bridge.
// these listen on the chain using the chain listeners and then handle the events.
func (r *Relayer) startChainIndexers(ctx context.Context) error {
    g, ctx := errgroup.WithContext(ctx)

    // TODO: good chance we wanna prepare these chain listeners up front and then listen later.
    for chainID := range r.cfg.GetChains() {
        chainID := chainID // capture func literal

        g.Go(func() error {
            err := r.runChainIndexer(ctx, chainID)
            if err != nil {
                return fmt.Errorf("could not runChainIndexer chain indexer for chain %d: %w", chainID, err)
            }
            return nil
        })
    }
    return nil
}

// runChainIndexer runs the chain indexer for a given chain.
// any events that an action exists for are indexed.
// nolint: cyclop
func (r *Relayer) runChainIndexer(ctx context.Context, chainID int) (err error) {
    chainListener := r.chainListeners[chainID]

    parser, err := fastbridge.NewParser(chainListener.Address())
    if err != nil {
        return fmt.Errorf("could not parse: %w", err)
    }

    err = chainListener.Listen(ctx, func(parentCtx context.Context, log types.Log) (err error) {
        et, parsedEvent, ok := parser.ParseEvent(log)
        // handle unknown event
        if !ok {
            if len(log.Topics) != 0 {
                logger.Warnf("unknown event %s", log.Topics[0])
            }
            return nil
        }

        ctx, span := r.metrics.Tracer().Start(parentCtx, fmt.Sprintf("handleLog-%s", et), trace.WithAttributes(
            attribute.String(metrics.TxHash, log.TxHash.String()),
            attribute.Int(metrics.Origin, chainID),
            attribute.String(metrics.Contract, log.Address.String()),
            attribute.String("block_hash", log.BlockHash.String()),
            attribute.Int64("block_number", int64(log.BlockNumber)),
        ))

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

        switch event := parsedEvent.(type) {
        case *fastbridge.FastBridgeBridgeRequested:
            err = r.handleBridgeRequestedLog(ctx, event, uint64(chainID))
            if err != nil {
                return fmt.Errorf("could not handle request: %w", err)
            }
        case *fastbridge.FastBridgeBridgeRelayed:
            // blocking lock on the txid mutex to ensure state transitions are not overrwitten
            unlocker := r.handlerMtx.Lock(hexutil.Encode(event.TransactionId[:]))
            defer unlocker.Unlock()

            // it wasn't me
            if event.Relayer != r.signer.Address() {
                //nolint: wrapcheck
                return r.setRelayRaceLost(ctx, event.TransactionId)
            }

            err = r.handleRelayLog(ctx, event)
            if err != nil {
                return fmt.Errorf("could not handle relay: %w", err)
            }
        case *fastbridge.FastBridgeBridgeProofProvided:
            unlocker := r.handlerMtx.Lock(hexutil.Encode(event.TransactionId[:]))
            defer unlocker.Unlock()

            // it wasn't me
            if event.Relayer != r.signer.Address() {
                //nolint: wrapcheck
                return r.setRelayRaceLost(ctx, event.TransactionId)
            }

            err = r.handleProofProvided(ctx, event)
            if err != nil {
                return fmt.Errorf("could not handle proof provided: %w", err)
            }
        case *fastbridge.FastBridgeBridgeDepositClaimed:
            unlocker := r.handlerMtx.Lock(hexutil.Encode(event.TransactionId[:]))
            defer unlocker.Unlock()

            // it wasn't me
            if event.Relayer != r.signer.Address() {
                //nolint: wrapcheck
                return r.setRelayRaceLost(ctx, event.TransactionId)
            }

            err = r.handleDepositClaimed(ctx, event)
            if err != nil {
                return fmt.Errorf("could not handle deposit claimed: %w", err)
            }
        }

        return nil
    })

    if err != nil {
        return fmt.Errorf("listener failed: %w", err)
    }
    return nil
}

var ethDecimals uint8 = 18

// getDecimals gets the decimals for the origin and dest tokens.
func (r *Relayer) getDecimalsFromBridgeTx(parentCtx context.Context, bridgeTx fastbridge.IFastBridgeBridgeTransaction) (originDecimals *uint8, destDecimals *uint8, err error) {
    ctx, span := r.metrics.Tracer().Start(parentCtx, "getDecimals", trace.WithAttributes(
        attribute.String("sender", bridgeTx.OriginSender.String()),
    ))

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

    // fetch the token decimals in parallel
    g, ctx := errgroup.WithContext(ctx)
    g.Go(func() error {
        originDecimals, err = r.getDecimals(ctx, bridgeTx.OriginToken, bridgeTx.OriginChainId)
        if err != nil {
            return fmt.Errorf("could not get origin decimals: %w", err)
        }
        return nil
    })
    g.Go(func() error {
        destDecimals, err = r.getDecimals(ctx, bridgeTx.DestToken, bridgeTx.DestChainId)
        if err != nil {
            return fmt.Errorf("could not get dest decimals: %w", err)
        }
        return nil
    })
    err = g.Wait()
    if err != nil {
        return nil, nil, fmt.Errorf("could not get decimals: %w", err)
    }

    return originDecimals, destDecimals, nil
}

// getDecimals gets the decimals for a token on a chain.
// It will attempt to load a result from the cache first.
// The cache will be updated if the result is fetched from RPC.
func (r *Relayer) getDecimals(ctx context.Context, addr common.Address, chainID uint32) (decimals *uint8, err error) {
    // attempt to load decimal from cache
    key := getDecimalsKey(addr, chainID)
    decimals, ok := r.decimalsCache.Load(key)
    if ok {
        return decimals, nil
    }

    if addr == util.EthAddress {
        return &ethDecimals, nil
    }

    // fetch decimals from RPC
    client, err := r.client.GetChainClient(ctx, int(chainID))
    if err != nil {
        return nil, fmt.Errorf("could not get client for chain %d: %w", chainID, err)
    }
    erc20, err := ierc20.NewIERC20(addr, client)
    if err != nil {
        return nil, fmt.Errorf("could not get token at %s: %w", addr.String(), err)
    }
    dec, err := erc20.Decimals(&bind.CallOpts{Context: ctx})
    if err != nil {
        return nil, fmt.Errorf("could not get decimals: %w", err)
    }

    // update the cache
    r.decimalsCache.Store(key, &dec)
    return &dec, nil
}

func getDecimalsKey(addr common.Address, chainID uint32) string {
    return fmt.Sprintf("%s-%d", addr.Hex(), chainID)
}

func (r *Relayer) handleDepositClaimed(ctx context.Context, event *fastbridge.FastBridgeBridgeDepositClaimed) error {
    err := r.db.UpdateQuoteRequestStatus(ctx, event.TransactionId, reldb.ClaimCompleted, nil)
    if err != nil {
        return fmt.Errorf("could not update request status: %w", err)
    }
    return nil
}

func (r *Relayer) setRelayRaceLost(ctx context.Context, transactionID [32]byte) error {
    err := r.db.UpdateQuoteRequestStatus(ctx, transactionID, reldb.RelayRaceLost, nil)
    // quote does not exist, no need to update status
    if err != nil && (errors.Is(err, reldb.ErrNoQuoteForID) || strings.Contains(err.Error(), reldb.ErrNoQuoteForID.Error())) {
        return nil
    }
    if err != nil {
        return fmt.Errorf("could not set relay race lost: %w", err)
    }
    return nil
}