synapsecns/sanguine

package base

import (
    "context"
    "errors"
    "fmt"
    "github.com/synapsecns/sanguine/core/dbcommon"
    "github.com/synapsecns/sanguine/services/scribe/db"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "gorm.io/gorm"
    "gorm.io/gorm/clause"
)

// StoreReceipt stores a receipt.
func (s Store) StoreReceipt(ctx context.Context, chainID uint32, receipt types.Receipt) error {
    dbTx := s.DB().WithContext(ctx)
    if s.DB().Dialector.Name() == dbcommon.Sqlite.String() {
        dbTx = dbTx.Clauses(clause.OnConflict{
            Columns:   []clause.Column{{Name: TxHashFieldName}, {Name: ChainIDFieldName}},
            DoNothing: true,
        })
    } else {
        dbTx = dbTx.Clauses(clause.Insert{
            Modifier: "IGNORE",
        })
    }
    dbTx = dbTx.Create(&Receipt{
        ChainID:           chainID,
        Type:              receipt.Type,
        PostState:         receipt.PostState,
        Status:            receipt.Status,
        CumulativeGasUsed: receipt.CumulativeGasUsed,
        Bloom:             receipt.Bloom.Bytes(),
        TxHash:            receipt.TxHash.String(),
        ContractAddress:   receipt.ContractAddress.String(),
        GasUsed:           receipt.GasUsed,
        BlockHash:         receipt.BlockHash.String(),
        BlockNumber:       receipt.BlockNumber.Uint64(),
        TransactionIndex:  uint64(receipt.TransactionIndex),
        Confirmed:         true,
    })

    if dbTx.Error != nil {
        return fmt.Errorf("could not store receipt: %w", dbTx.Error)
    }

    return nil
}

// ConfirmReceiptsForBlockHash confirms receipts for a given block hash.
func (s Store) ConfirmReceiptsForBlockHash(ctx context.Context, chainID uint32, blockHash common.Hash) error {
    dbTx := s.DB().WithContext(ctx).
        Model(&Receipt{}).
        Where(&Receipt{
            ChainID:   chainID,
            BlockHash: blockHash.String(),
        }).
        Update(ConfirmedFieldName, true)

    if dbTx.Error != nil {
        return fmt.Errorf("could not confirm receipt: %w", dbTx.Error)
    }

    return nil
}

// DeleteReceiptsForBlockHash deletes receipts with a given block hash.
func (s Store) DeleteReceiptsForBlockHash(ctx context.Context, chainID uint32, blockHash common.Hash) error {
    dbTx := s.DB().WithContext(ctx).
        Where(&Receipt{
            ChainID:   chainID,
            BlockHash: blockHash.String(),
        }).
        Delete(&Receipt{})

    if dbTx.Error != nil {
        return fmt.Errorf("could not delete receipts: %w", dbTx.Error)
    }

    return nil
}

// receiptFilterToQuery takes in a ReceiptFilter and converts it to a database-type Receipt.
// This is used to query with `WHERE` based on the filter.
func receiptFilterToQuery(receiptFilter db.ReceiptFilter) Receipt {
    return Receipt{
        ChainID:          receiptFilter.ChainID,
        TxHash:           receiptFilter.TxHash,
        ContractAddress:  receiptFilter.ContractAddress,
        BlockHash:        receiptFilter.BlockHash,
        BlockNumber:      receiptFilter.BlockNumber,
        TransactionIndex: receiptFilter.TransactionIndex,
        Confirmed:        receiptFilter.Confirmed,
    }
}

// RetrieveReceiptsWithFilter retrieves receipts with a filter given a page.
func (s Store) RetrieveReceiptsWithFilter(ctx context.Context, receiptFilter db.ReceiptFilter, page int) (receipts []types.Receipt, err error) {
    if page < 1 {
        page = 1
    }
    dbReceipts := []Receipt{}
    query := receiptFilterToQuery(receiptFilter)
    dbTx := s.DB().WithContext(ctx).
        Model(&Receipt{}).
        Where(&query).
        Order(fmt.Sprintf("%s desc, %s desc", BlockNumberFieldName, TransactionIndexFieldName)).
        Offset((page - 1) * PageSize).
        Limit(PageSize).
        Find(&dbReceipts)

    if dbTx.Error != nil {
        if errors.Is(dbTx.Error, gorm.ErrRecordNotFound) {
            return []types.Receipt{}, fmt.Errorf("could not find receipts with filter %+v: %w", receiptFilter, db.ErrNotFound)
        }
        return []types.Receipt{}, fmt.Errorf("could not retrieve receipts: %w", dbTx.Error)
    }

    parsedReceipts, err := s.buildReceiptsFromDBReceipts(ctx, dbReceipts, receiptFilter.ChainID)
    if err != nil {
        return []types.Receipt{}, fmt.Errorf("could not build receipts from db receipts: %w", err)
    }

    return parsedReceipts, nil
}

// RetrieveReceiptsInRange retrieves receipts that match an inputted filter and are within a range given a page.
func (s Store) RetrieveReceiptsInRange(ctx context.Context, receiptFilter db.ReceiptFilter, startBlock, endBlock uint64, page int) (receipts []types.Receipt, err error) {
    if page < 1 {
        page = 1
    }
    var dbReceipts []Receipt
    query := receiptFilterToQuery(receiptFilter)
    rangeQuery := fmt.Sprintf("%s BETWEEN ? AND ?", BlockNumberFieldName)
    dbTx := s.DB().WithContext(ctx).
        Model(&Receipt{}).
        Where(&query).
        Where(rangeQuery, startBlock, endBlock).
        Order(fmt.Sprintf("%s desc, %s desc", BlockNumberFieldName, TransactionIndexFieldName)).
        Offset((page - 1) * PageSize).
        Limit(PageSize).
        Find(&dbReceipts)

    if dbTx.Error != nil {
        if errors.Is(dbTx.Error, gorm.ErrRecordNotFound) {
            return []types.Receipt{}, fmt.Errorf("could not find receipts with filter %+v: %w", receiptFilter, db.ErrNotFound)
        }
        return []types.Receipt{}, fmt.Errorf("could not retrieve receipts: %w", dbTx.Error)
    }

    parsedReceipts, err := s.buildReceiptsFromDBReceipts(ctx, dbReceipts, receiptFilter.ChainID)
    if err != nil {
        return []types.Receipt{}, fmt.Errorf("could not build receipts from db receipts: %w", err)
    }

    return parsedReceipts, nil
}

func (s Store) buildReceiptsFromDBReceipts(ctx context.Context, dbReceipts []Receipt, chainID uint32) ([]types.Receipt, error) {
    var receipts []types.Receipt
    for i := range dbReceipts {
        dbReceipt := dbReceipts[i]
        // Retrieve Logs that match the receipt's tx hash in order to add them to the Receipt.
        logFilter := db.BuildLogFilter(nil, nil, &dbReceipt.TxHash, nil, nil, nil, nil)
        logFilter.ChainID = chainID

        var logs []*types.Log
        page := 1
        for {
            logGroup, err := s.RetrieveLogsWithFilter(ctx, logFilter, page)
            if err != nil {
                return []types.Receipt{}, fmt.Errorf("could not retrieve logs with tx hash %s and chain id %d: %w", dbReceipt.TxHash, chainID, err)
            }
            if len(logGroup) == 0 {
                break
            }
            page++
            logs = append(logs, logGroup...)
        }

        parsedReceipt := types.Receipt{
            Type:              dbReceipt.Type,
            PostState:         dbReceipt.PostState,
            Status:            dbReceipt.Status,
            CumulativeGasUsed: dbReceipt.CumulativeGasUsed,
            Bloom:             types.BytesToBloom(dbReceipt.Bloom),
            Logs:              logs,
            TxHash:            common.HexToHash(dbReceipt.TxHash),
            ContractAddress:   common.HexToAddress(dbReceipt.ContractAddress),
            GasUsed:           dbReceipt.GasUsed,
            BlockHash:         common.HexToHash(dbReceipt.BlockHash),
            BlockNumber:       big.NewInt(int64(dbReceipt.BlockNumber)),
            TransactionIndex:  uint(dbReceipt.TransactionIndex),
        }

        receipts = append(receipts, parsedReceipt)
    }

    return receipts, nil
}

// RetrieveReceiptCountForChain retrieves the count of receipts per chain.
func (s Store) RetrieveReceiptCountForChain(ctx context.Context, chainID uint32) (int64, error) {
    var count int64
    dbTx := s.DB().WithContext(ctx).
        Model(&Receipt{}).
        Where(&Receipt{ChainID: chainID}).
        Count(&count)

    if dbTx.Error != nil {
        return 0, fmt.Errorf("could not count receipts: %w", dbTx.Error)
    }

    return count, nil
}

// RetrieveReceiptsWithStaleBlockHash gets receipts that are from a reorged/stale block.
func (s Store) RetrieveReceiptsWithStaleBlockHash(ctx context.Context, chainID uint32, blockHashes []string, startBlock uint64, endBlock uint64) ([]types.Receipt, error) {
    var dbReceipts []Receipt
    dbTx := s.DB().WithContext(ctx).Model(&Receipt{}).Where("block_number >= ? ", startBlock).Where("block_number <= ? ", endBlock).Where("block_hash NOT IN (?)", blockHashes).Scan(&dbReceipts)
    if dbTx.Error != nil {
        return nil, fmt.Errorf("could not get receipts: %w", dbTx.Error)
    }
    parsedReceipts, err := s.buildReceiptsFromDBReceipts(ctx, dbReceipts, chainID)
    if err != nil {
        return []types.Receipt{}, fmt.Errorf("could not build receipts from db receipts: %w", err)
    }

    return parsedReceipts, nil
}