synapsecns/sanguine

package db

import (
    "context"
    "database/sql/driver"
    "errors"
    "fmt"
    "math/big"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/synapsecns/sanguine/core/dbcommon"
)

// Service is the interface for the tx queue database.
// note: the other files in this package (base, sqlite, mysql) provide a suggested implementation.
// you can implement these yourself. If you plan on importing them, you should wrap in your own service.
//
//go:generate go run github.com/vektra/mockery/v2 --name Service --output ./mocks --case=underscore
type Service interface {
    // GetNonceForChainID gets the nonce for a given chain id.
    GetNonceForChainID(ctx context.Context, fromAddress common.Address, chainID *big.Int) (nonce uint64, err error)
    // PutTXS stores a tx in the database.
    PutTXS(ctx context.Context, txs ...TX) error
    // GetTXS gets all txs for a given address and chain id. If chain id is nil, it will get all txs for the address.
    GetTXS(ctx context.Context, fromAddress common.Address, chainID *big.Int, options ...Option) (txs []TX, err error)
    // MarkAllBeforeNonceReplacedOrConfirmed marks all txs for a given chain id and address before a given nonce as replaced or confirmed.
    // TODO: cleaner function name
    MarkAllBeforeNonceReplacedOrConfirmed(ctx context.Context, signer common.Address, chainID *big.Int, nonce uint64) error
    // DBTransaction executes a transaction on the database.
    // the function passed in will be passed a new service that is scoped to the transaction.
    DBTransaction(ctx context.Context, f TransactionFunc) error
    // GetAllTXAttemptByStatus gets all txs for a given address and chain id with a given status.
    GetAllTXAttemptByStatus(ctx context.Context, fromAddress common.Address, chainID *big.Int, options ...Option) (txs []TX, err error)
    // GetNonceStatus returns the nonce status for a given nonce by aggregating all attempts and finding the highest status.
    GetNonceStatus(ctx context.Context, fromAddress common.Address, chainID *big.Int, nonce uint64) (status Status, err error)
    // GetNonceAttemptsByStatus gets all txs for a given address and chain id with a given status and nonce.
    GetNonceAttemptsByStatus(ctx context.Context, fromAddress common.Address, chainID *big.Int, nonce uint64, matchStatuses ...Status) (txs []TX, err error)
    // GetChainIDsByStatus gets the distinct chain ids for a given address and status.
    GetChainIDsByStatus(ctx context.Context, fromAddress common.Address, matchStatuses ...Status) (chainIDs []*big.Int, err error)
    // DeleteTXS deletes txs that are older than a given duration.
    DeleteTXS(ctx context.Context, maxAge time.Duration, matchStatuses ...Status) error
    // GetDistinctChainIDs gets the distinct chain ids for all txs.
    GetDistinctChainIDs(ctx context.Context) ([]*big.Int, error)
}

// Option is a type for specifying optional parameters.
type Option func(*options)

type options struct {
    statuses   []Status
    maxResults int
}

var _ OptionsFetcher = (*options)(nil)

// OptionsFetcher is the interface for fetching options.
type OptionsFetcher interface {
    Statuses() []Status
    MaxResults() int
}

func (o *options) MaxResults() int {
    return o.maxResults
}

func (o *options) Statuses() []Status {
    return o.statuses
}

// DefaultMaxResultsPerChain is the maximum number of transactions to return per chain id.
// it is exported for testing.
// TODO: this should be an option passed to the GetTXs function.
// TODO: temporarily reduced from 50 to 1 to increase resiliency.
const DefaultMaxResultsPerChain = 10

// ParseOptions parses the options.
func ParseOptions(opts ...Option) OptionsFetcher {
    myOptions := &options{
        statuses:   nil,
        maxResults: DefaultMaxResultsPerChain, // Default to 0 for no limit.
    }

    for _, opt := range opts {
        opt(myOptions)
    }

    return myOptions
}

// WithStatuses specifies the statuses to match.
func WithStatuses(statuses ...Status) Option {
    return func(opts *options) {
        opts.statuses = statuses
    }
}

// WithMaxResults specifies the maximum number of results to return.
func WithMaxResults(maxResults int) Option {
    return func(opts *options) {
        opts.maxResults = maxResults
    }
}

// TransactionFunc is a function that can be passed to DBTransaction.
type TransactionFunc func(ctx context.Context, svc Service) error

// SubmitterDBFactory is the interface for the tx queue database factory.
type SubmitterDBFactory interface {
    SubmitterDB() Service
}

// Status is the status of a tx.
//
//go:generate go run golang.org/x/tools/cmd/stringer -type=Status -linecomment
type Status uint8

// Important: do not modify the order of these constants.
// if one needs to be removed, replace it with a no-op status.
// additionally, due to the GetMaxNoncestatus function, statuses are currently assumed to be in order.
// if you need to modify this functionality, please update that function. to reflect that the highest status
// isno longer the expected end status.
const (
    // Pending is the status of a tx that has not been processed yet.
    Pending Status = iota + 1 // Pending
    // Stored is the status of a tx that has been stored.
    Stored // Stored
    // Submitted is the status of a tx that has been submitted.
    Submitted // Submitted
    // FailedSubmit is the status of a tx that has failed to submit.
    FailedSubmit // Failed
    // ReplacedOrConfirmed is the status of a tx that has been replaced by a new tx or confirmed. The actual status will be set later.
    ReplacedOrConfirmed // ReplacedOrConfirmed
    // Replaced is the status of a tx that has been replaced by a new tx.
    Replaced // Replaced
    // Confirmed is the status of a tx that has been confirmed.
    Confirmed // Confirmed
)

var allStatusTypes = []Status{Pending, Stored, Submitted, FailedSubmit, ReplacedOrConfirmed, Replaced, Confirmed}

// AllStatusTypes returns all status types.
// it is exported for testing purposes
//
// These are guaranteed to be in order.
func AllStatusTypes() []Status {
    return allStatusTypes
}

// check to make sure all statuses are included in all status types.
func _() {
    for i := 0; i < len(_Status_index); i++ {
        statusNum := i + 1
        status := Status(statusNum)
        if status.String() == "" {
            panic(fmt.Sprintf("invalid status: %d", status))
        }
        if status.String() != AllStatusTypes()[i].String() {
            panic(fmt.Sprintf("status string and all status types do not match: %s, %s", status.String(), AllStatusTypes()[i]))
        }
    }
}

// Int returns the uint8 representation of the status.
func (s Status) Int() uint8 {
    return uint8(s)
}

// GormDataType returns the gorm data type for the status.
func (s Status) GormDataType() string {
    return dbcommon.EnumDataType
}

// Scan implements the gorm Scanner interface.
func (s *Status) Scan(src interface{}) error {
    res, err := dbcommon.EnumScan(src)
    if err != nil {
        return fmt.Errorf("could not scan status: %w", err)
    }
    newStatus := Status(res)
    *s = newStatus

    found := false
    for _, status := range allStatusTypes {
        if status == *s {
            found = true
            break
        }
    }

    if !found {
        return fmt.Errorf("invalid status: %d", res)
    }

    return nil
}

// Value implements the gorm Valuer interface.
func (s *Status) Value() (driver.Value, error) {
    //nolint: wrapcheck
    return dbcommon.EnumValue(s)
}

var _ dbcommon.EnumInter = (*Status)(nil)

var (
    // ErrNoNonceForChain is the error returned when there is no nonce for a given chain id.
    ErrNoNonceForChain = errors.New("no nonce exists for this chain")
    // ErrNonceNotExist is the error returned when a nonce does not exist.
    ErrNonceNotExist = errors.New("nonce does not exist")
)