synapsecns/sanguine

package sql

import (
    "context"
    "fmt"
)

// StoreEvent stores a generic event that has the proper fields set by `eventToBridgeEvent`.
func (s *Store) StoreEvent(ctx context.Context, event interface{}) error {
    switch conv := event.(type) {
    case *BridgeEvent:
        dbTx := s.db.WithContext(ctx).Create(conv)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store bridge event: %w", dbTx.Error)
        }
    case *SwapEvent:
        dbTx := s.db.WithContext(ctx).Create(conv)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store swap event: %w", dbTx.Error)
        }
    case *MessageBusEvent:
        dbTx := s.db.WithContext(ctx).Create(conv)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store message event: %w", dbTx.Error)
        }
    case *CCTPEvent:
        dbTx := s.db.WithContext(ctx).Create(conv)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store cctp event: %w", dbTx.Error)
        }
    case *RFQEvent:
        dbTx := s.db.WithContext(ctx).Create(conv)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store rfq event: %w", dbTx.Error)
        }
    }
    return nil
}

// StoreEvents stores a list of events in batches.
//
//nolint:cyclop
func (s *Store) StoreEvents(ctx context.Context, events []interface{}) error {
    var bridgeEvents []*BridgeEvent
    var swapEvents []SwapEvent
    var messageBusEvents []MessageBusEvent
    var cctpEvents []*CCTPEvent
    var rfqEvents []*RFQEvent

    for _, event := range events {
        switch conv := event.(type) {
        case *BridgeEvent:
            bridgeEvents = append(bridgeEvents, conv)
        case SwapEvent:
            swapEvents = append(swapEvents, conv)
        case MessageBusEvent:
            messageBusEvents = append(messageBusEvents, conv)
        case *CCTPEvent:
            cctpEvents = append(cctpEvents, conv)
        case *RFQEvent:
            rfqEvents = append(rfqEvents, conv)
        }
    }

    // TODO: maybe switch this out with a generic
    if len(bridgeEvents) > 0 {
        dbTx := s.db.WithContext(ctx).Create(&bridgeEvents)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store bridge events: %w", dbTx.Error)
        }
    }

    if len(swapEvents) > 0 {
        dbTx := s.db.WithContext(ctx).Create(&swapEvents)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store swap events: %w", dbTx.Error)
        }
    }

    if len(messageBusEvents) > 0 {
        dbTx := s.db.WithContext(ctx).Create(&messageBusEvents)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store message event: %w", dbTx.Error)
        }
    }

    if len(cctpEvents) > 0 {
        dbTx := s.db.WithContext(ctx).Create(&cctpEvents)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store cctp event: %w", dbTx.Error)
        }
    }

    if len(rfqEvents) > 0 {
        dbTx := s.db.WithContext(ctx).Create(&rfqEvents)
        if dbTx.Error != nil {
            return fmt.Errorf("failed to store rfq event: %w", dbTx.Error)
        }
    }

    return nil
}

// StoreLastBlock stores the last block number that has been backfilled for a given chain.
func (s *Store) StoreLastBlock(ctx context.Context, chainID uint32, blockNumber uint64, contractAddress string) error {
    var lastBlock LastBlock
    dbTx := s.db.WithContext(ctx).
        Where(&LastBlock{
            ChainID:         chainID,
            ContractAddress: contractAddress,
        }).
        Order("block_number DESC").
        Limit(1).
        Find(&lastBlock)
    if dbTx.Error == nil && blockNumber > lastBlock.BlockNumber {
        lastBlock.ChainID = chainID
        lastBlock.BlockNumber = blockNumber
        lastBlock.ContractAddress = contractAddress
        dbTx = s.db.WithContext(ctx).Create(&lastBlock)
        if dbTx.Error != nil {
            return fmt.Errorf("could not store last block: %w", dbTx.Error)
        }
    }

    return nil
}

// StoreTokenIndex stores the token index data.
func (s *Store) StoreTokenIndex(ctx context.Context, chainID uint32, tokenIndex uint8, tokenAddress string, contractAddress string) error {
    entry := TokenIndex{}
    dbTx := s.db.WithContext(ctx).
        Model(&TokenIndex{}).
        Where(&TokenIndex{
            ChainID:         chainID,
            TokenIndex:      tokenIndex,
            ContractAddress: contractAddress,
        }).
        Limit(1).
        Find(&entry)
    if dbTx.Error != nil {
        return fmt.Errorf("could not retrieve last block: %w", dbTx.Error)
    }
    if tokenAddress != entry.TokenAddress {
        dbTx = s.db.WithContext(ctx).
            Model(&TokenIndex{}).
            Create(&TokenIndex{
                ChainID:         chainID,
                TokenIndex:      tokenIndex,
                ContractAddress: contractAddress,
                TokenAddress:    tokenAddress,
            })
        if dbTx.Error != nil {
            return fmt.Errorf("could not store last block: %w", dbTx.Error)
        }

        return nil
    }
    return nil
}

// StoreSwapFee stores the swap fee.
func (s *Store) StoreSwapFee(ctx context.Context, chainID uint32, blockNumber uint64, contractAddress string, fee uint64, feeType string) error {
    entry := SwapFees{}
    dbTx := s.db.WithContext(ctx).
        Model(&SwapFees{}).
        Where(&SwapFees{
            ChainID:         chainID,
            BlockNumber:     blockNumber,
            ContractAddress: contractAddress,
            FeeType:         feeType,
        }).
        Limit(1).
        Find(&entry)
    if dbTx.Error != nil {
        return fmt.Errorf("could not retrieve last block: %w", dbTx.Error)
    }
    if blockNumber != entry.BlockNumber {
        dbTx = s.db.WithContext(ctx).
            Model(&SwapFees{}).
            Create(&SwapFees{
                ChainID:         chainID,
                ContractAddress: contractAddress,
                BlockNumber:     blockNumber,
                FeeType:         feeType,
                Fee:             fee,
            })
        if dbTx.Error != nil {
            return fmt.Errorf("could not store last block: %w", dbTx.Error)
        }

        return nil
    }
    return nil
}