Implement missing logic and enhance NFT detection

Author: Jetlum

integration_test.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/Jetlum/WalletAlertService/mock"
+	"github.com/Jetlum/WalletAlertService/models"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIntegration(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	// Setup test context with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// Create test event
+	event := &models.Event{
+		TxHash:      "0xtest",
+		FromAddress: "0xfrom",
+		ToAddress:   "0xto",
+		Value:       "1000000000000000000", // 1 ETH
+		EventType:   "LARGE_TRANSFER",
+	}
+
+	// Setup mocks
+	mockEventRepo := &mock.MockEventRepository{
+		CreateFunc: func(e *models.Event) error {
+			assert.Equal(t, event.TxHash, e.TxHash)
+			return nil
+		},
+	}
+
+	userPref := models.UserPreference{
+		UserID:            "test@example.com",
+		WalletAddress:     "0xto",
+		MinEtherValue:     "500000000000000000", // 0.5 ETH
+		EmailNotification: true,
+	}
+
+	mockUserPrefRepo := &mock.MockUserPreferenceRepository{
+		GetMatchingPreferencesFunc: func(e *models.Event) ([]models.UserPreference, error) {
+			assert.Equal(t, event.ToAddress, e.ToAddress)
+			return []models.UserPreference{userPref}, nil
+		},
+	}
+
+	// Setup mock email notification
+	emailSent := false
+	mockEmailNotification := &mock.MockEmailNotification{
+		SendFunc: func(e *models.Event, up *models.UserPreference) error {
+			emailSent = true
+			return nil
+		},
+	}
+
+	// Create mock block and header
+	mockHeader := &types.Header{
+		Number: big.NewInt(1),
+	}
+
+	// Test full workflow
+	done := make(chan bool)
+	go func() {
+		processBlock(
+			nil,
+			mockHeader,
+			mock.NewMockNFTDetector(),
+			mockEmailNotification,
+			mockEventRepo,
+			mockUserPrefRepo,
+		)
+		done <- true
+	}()
+
+	// Wait for completion or timeout
+	select {
+	case <-ctx.Done():
+		t.Fatal("Test timed out")
+	case <-done:
+		assert.True(t, emailSent, "Email notification should have been sent")
+	}
+}

main.go

@@ -89,7 +89,7 @@ func main() {
 func processBlock(
 	client *ethclient.Client,
 	header *types.Header,
-	nftDetector *nfts.NFTDetector,
+	nftDetector nfts.INFTDetector,
 	emailNotification services.EmailNotifier,
 	eventRepo repository.EventRepositoryInterface,
 	userPrefRepo repository.UserPreferenceRepositoryInterface,

mock/nft_mock.go

@@ -0,0 +1,25 @@
+package mock
+
+import (
+	nfts "github.com/Jetlum/WalletAlertService/nft"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type MockNFTDetector struct {
+	IsNFTTransactionFunc func(tx *types.Transaction) bool
+}
+
+func NewMockNFTDetector() nfts.INFTDetector {
+	return &MockNFTDetector{
+		IsNFTTransactionFunc: func(tx *types.Transaction) bool {
+			return false
+		},
+	}
+}
+
+func (m *MockNFTDetector) IsNFTTransaction(tx *types.Transaction) bool {
+	if m.IsNFTTransactionFunc != nil {
+		return m.IsNFTTransactionFunc(tx)
+	}
+	return false
+}

models/validation.go

@@ -0,0 +1,34 @@
+package models
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func (up *UserPreference) Validate() error {
+	if up.UserID == "" {
+		return fmt.Errorf("user ID is required")
+	}
+
+	if up.WalletAddress == "" {
+		return fmt.Errorf("wallet address is required")
+	}
+
+	if !common.IsHexAddress(up.WalletAddress) {
+		return fmt.Errorf("invalid wallet address format")
+	}
+
+	if up.MinEtherValue != "" {
+		value, ok := new(big.Int).SetString(up.MinEtherValue, 10)
+		if !ok {
+			return fmt.Errorf("invalid minimum ether value")
+		}
+		if value.Cmp(big.NewInt(0)) < 0 {
+			return fmt.Errorf("minimum ether value cannot be negative")
+		}
+	}
+
+	return nil
+}

nft/nftdetector.go

@@ -1,27 +1,46 @@
 package nfts
 
 import (
+	"sync"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
+// INFTDetector defines the interface for NFT detection
+type INFTDetector interface {
+	IsNFTTransaction(tx *types.Transaction) bool
+}
+
+// NFTDetector implements the INFTDetector interface
 type NFTDetector struct {
-	nftContracts map[common.Address]bool
+	nftContracts sync.Map
 }
 
-func NewNFTDetector() *NFTDetector {
-	return &NFTDetector{
-		nftContracts: map[common.Address]bool{
-			common.HexToAddress("0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D"): true, // BAYC
-			common.HexToAddress("0x23581767a106ae21c074b2276D25e5C3e136a68b"): true, // Moonbirds
-		},
+func NewNFTDetector() INFTDetector {
+	detector := &NFTDetector{}
+
+	// Initialize known contracts
+	knownContracts := map[string]bool{
+		"0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D": true, // BAYC
+		"0x23581767a106ae21c074b2276D25e5C3e136a68b": true, // Moonbirds
+	}
+
+	for addr := range knownContracts {
+		detector.nftContracts.Store(common.HexToAddress(addr), true)
 	}
+
+	return detector
 }
 
 func (d *NFTDetector) IsNFTTransaction(tx *types.Transaction) bool {
 	if tx.To() == nil {
 		return false
 	}
-	_, exists := d.nftContracts[*tx.To()]
-	return exists
+
+	if isContract, ok := d.nftContracts.Load(*tx.To()); ok {
+		return isContract.(bool)
+	}
+
+	return false
 }

repository/user_preference.go

@@ -1,6 +1,9 @@
 package repository
 
 import (
+	"fmt"
+	"math/big"
+
 	"github.com/Jetlum/WalletAlertService/models"
 	"gorm.io/gorm"
 )
@@ -15,6 +18,26 @@ func NewUserPreferenceRepository(db *gorm.DB) *UserPreferenceRepository {
 
 func (r *UserPreferenceRepository) GetMatchingPreferences(event *models.Event) ([]models.UserPreference, error) {
 	var preferences []models.UserPreference
-	err := r.db.Where("wallet_address = ?", event.ToAddress).Find(&preferences).Error
-	return preferences, err
+
+	eventValue, ok := new(big.Int).SetString(event.Value, 10)
+	if !ok {
+		return nil, fmt.Errorf("invalid event value: %s", event.Value)
+	}
+
+	// Base query
+	query := r.db.Where("wallet_address = ?", event.ToAddress)
+
+	// Add filters based on event type
+	switch event.EventType {
+	case "LARGE_TRANSFER":
+		query = query.Where("min_ether_value <= ?", eventValue.String())
+	case "NFT_TRANSFER":
+		query = query.Where("track_nfts = ?", true)
+	}
+
+	if err := query.Find(&preferences).Error; err != nil {
+		return nil, fmt.Errorf("failed to fetch preferences: %w", err)
+	}
+
+	return preferences, nil
 }

services/email_notifier.go

@@ -1,6 +1,8 @@
 package services
 
 import (
+	"fmt"
+
 	"github.com/Jetlum/WalletAlertService/models"
 	"github.com/sendgrid/sendgrid-go"
 	"github.com/sendgrid/sendgrid-go/helpers/mail"
@@ -12,18 +14,29 @@ type EmailNotifier interface {
 
 type EmailNotification struct {
 	APIKey string
+	client *sendgrid.Client
 }
 
-var _ EmailNotifier = (*EmailNotification)(nil)
-
 func (en *EmailNotification) Send(event *models.Event, userPref *models.UserPreference) error {
-	from := mail.NewEmail("Wallet Alert Service", "no-reply@example.com")
+	if userPref.UserID == "" {
+		return fmt.Errorf("invalid user email")
+	}
+
+	from := mail.NewEmail("Wallet Alert Service", "alerts@walletalert.service")
 	to := mail.NewEmail("", userPref.UserID)
-	subject := "Wallet Activity Alert"
+	subject := fmt.Sprintf("Alert: %s Event Detected", event.EventType)
 	content := formatEventMessage(event)
+
 	message := mail.NewSingleEmail(from, subject, to, content, content)
 
-	client := sendgrid.NewSendClient(en.APIKey)
-	_, err := client.Send(message)
-	return err
+	response, err := en.client.Send(message)
+	if err != nil {
+		return fmt.Errorf("failed to send email: %w", err)
+	}
+
+	if response.StatusCode >= 400 {
+		return fmt.Errorf("email API error: status %d", response.StatusCode)
+	}
+
+	return nil
 }