synapsecns/sanguine

package base

import (
    "context"
    "errors"
    "fmt"

    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/synapsecns/sanguine/services/rfq/guard/guarddb"
    "gorm.io/gorm"
    "gorm.io/gorm/clause"
)

// StorePendingProven stores a quote request.
func (s Store) StorePendingProven(ctx context.Context, proven guarddb.PendingProven) error {
    model := FromPendingProven(proven)
    dbTx := s.DB().WithContext(ctx).Clauses(clause.OnConflict{
        Columns:   []clause.Column{{Name: transactionIDFieldName}},
        DoUpdates: clause.AssignmentColumns([]string{transactionIDFieldName}),
    }).Create(&model)
    if dbTx.Error != nil {
        return fmt.Errorf("could not store proven: %w", dbTx.Error)
    }
    return nil
}

// UpdatePendingProvenStatus updates the status of a pending proven.
func (s Store) UpdatePendingProvenStatus(ctx context.Context, id [32]byte, status guarddb.PendingProvenStatus) error {
    tx := s.DB().WithContext(ctx).Model(&PendingProvenModel{}).
        Where(fmt.Sprintf("%s = ?", transactionIDFieldName), hexutil.Encode(id[:])).
        Update(statusFieldName, status)
    if tx.Error != nil {
        return fmt.Errorf("could not update: %w", tx.Error)
    }
    return nil
}

// GetPendingProvensByStatus gets pending provens by status.
func (s Store) GetPendingProvensByStatus(ctx context.Context, matchStatuses ...guarddb.PendingProvenStatus) (res []*guarddb.PendingProven, _ error) {
    var provenResults []PendingProvenModel

    inArgs := make([]int, len(matchStatuses))
    for i := range matchStatuses {
        inArgs[i] = int(matchStatuses[i].Int())
    }

    // TODO: consider pagination
    tx := s.DB().WithContext(ctx).Model(&PendingProvenModel{}).Where(fmt.Sprintf("%s IN ?", statusFieldName), inArgs).Find(&provenResults)
    if tx.Error != nil {
        return []*guarddb.PendingProven{}, fmt.Errorf("could not get db results: %w", tx.Error)
    }

    for _, result := range provenResults {
        marshaled, err := result.ToPendingProven()
        if err != nil {
            return []*guarddb.PendingProven{}, fmt.Errorf("could not get provens")
        }
        res = append(res, marshaled)
    }
    return res, nil
}

// GetPendingProvenByID gets a quote request by id. Should return ErrNoProvenForID if not found.
func (s Store) GetPendingProvenByID(ctx context.Context, id [32]byte) (*guarddb.PendingProven, error) {
    var modelResult PendingProvenModel
    tx := s.DB().WithContext(ctx).Where(fmt.Sprintf("%s = ?", transactionIDFieldName), hexutil.Encode(id[:])).First(&modelResult)
    if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
        return nil, guarddb.ErrNoProvenForID
    }

    if tx.Error != nil {
        return nil, fmt.Errorf("could not get proven")
    }

    qr, err := modelResult.ToPendingProven()
    if err != nil {
        return nil, err
    }
    return qr, nil
}