Strategyupd (#438)

* wip

* feat: comments and APY for strategies

* wip: kong

* feat: update meta

* feat: add cove registry support

* chores: meta cove

* feat: kong db setup

* update metas

Author: Majorfi

cmd/flags.process.go

@@ -1,25 +1,11 @@
 package main
 
-import "strings"
-
 type TProcess string
 
 const (
-	ProcessServer          TProcess = "server"
-	ProcessVaultMigrations TProcess = "vaultmigrations"
-	ProcessAPY             TProcess = "apy"
+	ProcessServer TProcess = "server"
 )
 
 func handleProcessInitialization(rawProcess *string) TProcess {
-	switch strings.ToLower(*rawProcess) {
-	case string(ProcessServer):
-		process = ProcessServer
-	case string(ProcessVaultMigrations):
-		process = ProcessVaultMigrations
-	case string(ProcessAPY):
-		process = ProcessAPY
-	default:
-		process = ProcessServer
-	}
-	return process
+	return ProcessServer
 }

cmd/main.go

@@ -1,14 +1,10 @@
 package main
 
 import (
-	"sync"
-
 	"github.com/yearn/ydaemon/common/ethereum"
 	"github.com/yearn/ydaemon/common/logs"
 	"github.com/yearn/ydaemon/internal"
 	"github.com/yearn/ydaemon/internal/storage"
-	"github.com/yearn/ydaemon/processes/apr"
-	"github.com/yearn/ydaemon/processes/vaultsMigrations"
 )
 
 func processServer(chainID uint64) {
@@ -31,52 +27,13 @@ func main() {
 	storage.InitializeStorage()
 	go ListenToSignals()
 
-	var wg sync.WaitGroup
-	logs.Info(`Running external processes...`)
-
-	/** 🔵 - Yearn *************************************************************************************
-	** This section of the code is responsible for running external processes. Each process is associated
-	** with a specific chain ID and is run concurrently for efficiency. The processes include fetching
-	** and updating prices, initializing V2, building token lists, running vault migrations, initializing
-	** daily blocks, initializing APY, etc.
-	**
-	** The status of each process is tracked and updated for each chain ID. Once all processes for a
-	** chain ID have completed, the status is set to "OK".
-	**
-	** The server is ready to accept requests once all processes have completed.
-	**************************************************************************************************/
-	switch process {
-	case ProcessServer:
-		logs.Info(`Running yDaemon server process...`)
-		go NewRouter().Run(`:8080`)
-		go TriggerTgMessage(`💛 - yDaemon v` + GetVersion() + ` is ready to accept requests: https://ydaemon.yearn.fi/`)
-
-		for _, chainID := range chains {
-			go processServer(chainID)
-		}
-		logs.Success(`Server ready on port 8080 !`)
-		select {}
-
-	case ProcessVaultMigrations:
-		logs.Info(`Running yDaemon vault migrations process...`)
-		for _, chainID := range chains {
-			wg.Add(1)
-			go func(chainID uint64) {
-				vaultsMigrations.Run(chainID)
-				wg.Done()
-			}(chainID)
-		}
-		wg.Wait()
+	logs.Info(`Running yDaemon server process...`)
+	go NewRouter().Run(`:8080`)
+	go TriggerTgMessage(`💛 - yDaemon v` + GetVersion() + ` is ready to accept requests: https://ydaemon.yearn.fi/`)
 
-	case ProcessAPY:
-		logs.Info(`Running yDaemon APY Initializer process...`)
-		for _, chainID := range chains {
-			wg.Add(1)
-			go func(chainID uint64) {
-				apr.Run(chainID)
-				wg.Done()
-			}(chainID)
-		}
-		wg.Wait()
+	for _, chainID := range chains {
+		go processServer(chainID)
 	}
+	logs.Success(`Server ready on port 8080 !`)
+	select {}
 }

cmd/server.go

@@ -71,6 +71,7 @@ func NewRouter() *gin.Engine {
 		router.GET(`vaults/pendle`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsYearnPendle))
 		router.GET(`vaults/optimism`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsOptimism))
 		router.GET(`vaults/pooltogether`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsYearnPoolTogether))
+		router.GET(`vaults/cove`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsYearnCove))
 		router.GET(`vaults/morpho`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsMorpho))
 		router.GET(`vaults/ajna`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsAjna))
 		router.GET(`vaults/velodrome`, CacheSimplifiedVaults(cachingStore, 5*time.Minute, c.GetIsVelodrome))

cmd/status.go

@@ -1,19 +1,50 @@
 package main
 
-import "github.com/yearn/ydaemon/common/env"
+import (
+	"sync"
 
-var STATUS_FOR_CHAINID = map[uint64]string{}
+	"github.com/yearn/ydaemon/common/env"
+)
 
+/**************************************************************************************************
+** statusStore is a thread-safe map for storing chain status information
+** It uses sync.Map to handle concurrent access safely
+**************************************************************************************************/
+var (
+	statusStore sync.Map
+)
+
+/**************************************************************************************************
+** init initializes the status store for all configured chains
+** Sets initial status as "Not Started" for each chain
+**************************************************************************************************/
 func init() {
 	for chainID := range env.GetChains() {
 		setStatusForChainID(chainID, "Not Started")
 	}
 }
 
+/**************************************************************************************************
+** setStatusForChainID updates the status for a specific chain ID
+** Thread-safe operation using sync.Map.Store
+**
+** @param chainID uint64 - The chain ID to update
+** @param status string - The new status to set
+**************************************************************************************************/
 func setStatusForChainID(chainID uint64, status string) {
-	STATUS_FOR_CHAINID[chainID] = status
+	statusStore.Store(chainID, status)
 }
 
+/**************************************************************************************************
+** getStatusForChainID retrieves the status for a specific chain ID
+** Thread-safe operation using sync.Map.Load
+**
+** @param chainID uint64 - The chain ID to query
+** @return string - The current status of the chain
+**************************************************************************************************/
 func getStatusForChainID(chainID uint64) string {
-	return STATUS_FOR_CHAINID[chainID]
+	if status, ok := statusStore.Load(chainID); ok {
+		return status.(string)
+	}
+	return "Not Started"
 }

common/bigNumber/float.go

@@ -289,6 +289,9 @@ func (b *Float) String() string {
 ** @return bool True if the value is zero, false otherwise
 **************************************************************************************************/
 func (b *Float) IsZero() bool {
+	if b == nil {
+		return true
+	}
 	return b.Cmp(big.NewFloat(0)) == 0
 }