synapsecns/sanguine

package graph

import (
    "context"
    "fmt"
    ethCore "github.com/ethereum/go-ethereum/core"
    "github.com/synapsecns/sanguine/services/scribe/backend"
    "math/big"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ipfs/go-log"
    "github.com/jpillora/backoff"
    "github.com/synapsecns/sanguine/services/scribe/db"
    "github.com/synapsecns/sanguine/services/scribe/graphql/server/graph/model"
)

var logger = log.Logger("scribe-graph")

func (r Resolver) receiptsToModelReceipts(receipts []types.Receipt, chainID uint32) []*model.Receipt {
    modelReceipts := make([]*model.Receipt, len(receipts))

    for i, receipt := range receipts {
        modelReceipts[i] = r.receiptToModelReceipt(receipt, chainID)
    }

    return modelReceipts
}

func (r Resolver) receiptToModelReceipt(receipt types.Receipt, chainID uint32) *model.Receipt {
    return &model.Receipt{
        ChainID:           int(chainID),
        Type:              int(receipt.Type),
        PostState:         string(receipt.PostState),
        Status:            int(receipt.Status),
        CumulativeGasUsed: int(receipt.CumulativeGasUsed),
        Bloom:             common.Bytes2Hex(receipt.Bloom.Bytes()),
        TxHash:            receipt.TxHash.String(),
        ContractAddress:   receipt.ContractAddress.String(),
        GasUsed:           int(receipt.GasUsed),
        BlockNumber:       int(receipt.BlockNumber.Int64()),
        TransactionIndex:  int(receipt.TransactionIndex),
    }
}

func (r Resolver) logsToModelLogs(logs []*types.Log, chainID uint32) []*model.Log {
    modelLogs := make([]*model.Log, len(logs))
    for i, log := range logs {
        modelLogs[i] = r.logToModelLog(log, chainID)
    }

    return modelLogs
}

func (r Resolver) logToModelLog(log *types.Log, chainID uint32) *model.Log {
    topicsList := make([]string, len(log.Topics))

    for i, topic := range log.Topics {
        topicsList[i] = topic.String()
    }

    return &model.Log{
        ContractAddress: log.Address.String(),
        ChainID:         int(chainID),
        Topics:          topicsList,
        Data:            common.Bytes2Hex(log.Data),
        BlockNumber:     int(log.BlockNumber),
        TxHash:          log.TxHash.String(),
        TxIndex:         int(log.TxIndex),
        BlockHash:       log.BlockHash.String(),
        Index:           int(log.Index),
        Removed:         log.Removed,
    }
}

func (r Resolver) ethTxsToModelTransactions(ctx context.Context, ethTxs []db.TxWithBlockNumber, chainID uint32) []*model.Transaction {
    modelTxs := make([]*model.Transaction, len(ethTxs))

    for i := range ethTxs {
        ethTx := ethTxs[i]
        modelTxs[i] = r.ethTxToModelTransaction(ethTx.Tx, chainID)

        // Return empty sender if that this operation errors (will only occur in tests or invalid txs).
        msgFrom, _ := ethCore.TransactionToMessage(&ethTx.Tx, types.LatestSignerForChainID(ethTx.Tx.ChainId()), big.NewInt(1))
        modelTxs[i].Sender = msgFrom.From.String()

        timestamp, err := r.DB.RetrieveBlockTime(ctx, chainID, ethTx.BlockNumber)
        if err != nil || timestamp == 0 {
            newBlockTime, err := r.getBlockTime(ctx, chainID, ethTx.BlockNumber)
            if err != nil {
                continue
            }

            timestamp = *newBlockTime
            err = r.DB.StoreBlockTime(ctx, chainID, ethTx.BlockNumber, *newBlockTime)
            if err != nil {
                continue
            }
        }

        modelTxs[i].Timestamp = int(timestamp)
    }

    return modelTxs
}

func (r Resolver) ethTxToModelTransaction(ethTx types.Transaction, chainID uint32) *model.Transaction {
    protected := ethTx.Protected()
    return &model.Transaction{
        ChainID:   int(chainID),
        TxHash:    ethTx.Hash().String(),
        Protected: protected,
        Type:      int(ethTx.Type()),
        Data:      common.Bytes2Hex(ethTx.Data()),
        Gas:       int(ethTx.Gas()),
        GasPrice:  int(ethTx.GasPrice().Uint64()),
        GasTipCap: ethTx.GasFeeCap().String(),
        GasFeeCap: ethTx.GasTipCap().String(),
        Value:     ethTx.Value().String(),
        Nonce:     int(ethTx.Nonce()),
        To:        ethTx.To().String(),
    }
}

// getBlockTime retrieves a singular blocktime.
//
//nolint:gocognit,cyclop
func (r Resolver) getBlockTime(ctx context.Context, chainID uint32, blockNumber uint64) (*uint64, error) {
    b := &backoff.Backoff{
        Factor: 2,
        Jitter: true,
        Min:    30 * time.Millisecond,
        Max:    5 * time.Second,
    }

    timeout := time.Duration(0)
    var backendClient backend.ScribeBackend
    backendClient, err := backend.DialBackend(ctx, fmt.Sprintf("%s/%d", r.OmniRPCURL, chainID), r.Metrics)
    if err != nil {
        return nil, fmt.Errorf("could not create backend client: %w", err)
    }

    for {
        select {
        case <-ctx.Done():

            return nil, fmt.Errorf("context canceled: %w", ctx.Err())
        case <-time.After(timeout):
            block, err := backendClient.HeaderByNumber(ctx, big.NewInt(int64(blockNumber)))

            if err != nil {
                timeout = b.Duration()
                fmt.Println("TESTING--", fmt.Sprintf("%s/%d", r.OmniRPCURL, chainID), err)

                continue
            }
            blockTime := block.Time
            return &blockTime, nil
        }
    }
}