synapsecns/sanguine

package base

import (
    "context"
    "errors"
    "fmt"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/synapsecns/sanguine/core/dbcommon"
    "github.com/synapsecns/sanguine/services/scribe/db"
    "gorm.io/gorm"
    "gorm.io/gorm/clause"
)

// StoreEthTx stores a processed tx.
func (s Store) StoreEthTx(ctx context.Context, tx *types.Transaction, chainID uint32, blockHash common.Hash, blockNumber uint64, transactionIndex uint64) error {
    marshalledTx, err := tx.MarshalBinary()
    if err != nil {
        return fmt.Errorf("could not marshall tx to binary: %w", err)
    }
    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(&EthTx{
        TxHash:           tx.Hash().String(),
        ChainID:          chainID,
        BlockHash:        blockHash.String(),
        BlockNumber:      blockNumber,
        RawTx:            marshalledTx,
        GasFeeCap:        tx.GasFeeCap().Uint64(),
        GasTipCap:        tx.GasTipCap().Uint64(),
        Confirmed:        true,
        TransactionIndex: transactionIndex,
    })

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

    return nil
}

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

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

    return nil
}

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

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

    return nil
}

// ethTxFilterToQuery converts an ethTxFilter to a database-type EthTx.
// This is used to query with `WHERE` based on the filter.
func ethTxFilterToQuery(ethTxFilter db.EthTxFilter) EthTx {
    return EthTx{
        ChainID:     ethTxFilter.ChainID,
        TxHash:      ethTxFilter.TxHash,
        BlockHash:   ethTxFilter.BlockHash,
        BlockNumber: ethTxFilter.BlockNumber,
        Confirmed:   ethTxFilter.Confirmed,
    }
}

// RetrieveEthTxsWithFilter retrieves eth transactions with a filter given a page.
func (s Store) RetrieveEthTxsWithFilter(ctx context.Context, ethTxFilter db.EthTxFilter, page int) ([]db.TxWithBlockNumber, error) {
    if page < 1 {
        page = 1
    }
    dbEthTxs := []EthTx{}
    query := ethTxFilterToQuery(ethTxFilter)
    dbTx := s.DB().WithContext(ctx).
        Model(&EthTx{}).
        Where(&query).
        Order(fmt.Sprintf("%s desc, %s desc", BlockNumberFieldName, TransactionIndexFieldName)).
        Offset((page - 1) * PageSize).
        Limit(PageSize).
        Find(&dbEthTxs)

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

    parsedEthTxs, err := buildEthTxsFromDBEthTxs(dbEthTxs)
    if err != nil {
        return []db.TxWithBlockNumber{}, fmt.Errorf("could not build eth txs: %w", err)
    }

    return parsedEthTxs, nil
}

// RetrieveEthTxsInRange retrieves eth transactions that match an inputted filter and are within a range given a page.
func (s Store) RetrieveEthTxsInRange(ctx context.Context, ethTxFilter db.EthTxFilter, startBlock, endBlock uint64, page int) ([]db.TxWithBlockNumber, error) {
    if page < 1 {
        page = 1
    }
    dbEthTxs := []EthTx{}
    query := ethTxFilterToQuery(ethTxFilter)
    rangeQuery := fmt.Sprintf("%s BETWEEN ? AND ?", BlockNumberFieldName)
    dbTx := s.DB().WithContext(ctx).
        Model(&EthTx{}).
        Where(&query).
        Where(rangeQuery, startBlock, endBlock).
        Order(fmt.Sprintf("%s desc, %s desc", BlockNumberFieldName, TransactionIndexFieldName)).
        Offset((page - 1) * PageSize).
        Limit(PageSize).
        Find(&dbEthTxs)

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

    parsedEthTxs, err := buildEthTxsFromDBEthTxs(dbEthTxs)
    if err != nil {
        return []db.TxWithBlockNumber{}, fmt.Errorf("could not build eth txs: %w", err)
    }

    return parsedEthTxs, nil
}

func buildEthTxsFromDBEthTxs(dbEthTxs []EthTx) ([]db.TxWithBlockNumber, error) {
    ethTxs := []db.TxWithBlockNumber{}
    for _, dbEthTx := range dbEthTxs {
        ethTx := types.Transaction{}
        if err := ethTx.UnmarshalBinary(dbEthTx.RawTx); err != nil {
            return []db.TxWithBlockNumber{}, fmt.Errorf("could not unmarshall eth tx: %w", err)
        }
        ethTxs = append(ethTxs, db.TxWithBlockNumber{Tx: ethTx, BlockNumber: dbEthTx.BlockNumber})
    }

    return ethTxs, nil
}