Merge pull request #2 from kadena-community/vote-popup

Vote popup

README.md

@@ -7,12 +7,8 @@ Kadena Cabinet is a Community Advisory Board (CAB) where KDA token holders come
 - **Chainweb Node Instance:**
   - An instance of the [Chainweb Node](https://github.com/kadena-io/chainweb-node) with the `allowReadsInLocal: true` parameter set.
 
-- **One of the Following:**
-  - A [Kadena GraphQL](https://github.com/kadena-community/kadena.js/tree/main/packages/apps/graph) server.
-  - Access to the `events` endpoint from [Chainweb Data](https://github.com/kadena-io/chainweb-data).
-  - SQL access to the PostgreSQL database from [Chainweb Data](https://github.com/kadena-io/chainweb-data).
-
-
+- A **[Kadena GraphQL](https://github.com/kadena-community/kadena.js/tree/main/packages/apps/graph)** server
+
 ## Project Structure
 
 - `pact/`: Smart contracts and related files for on-chain governance.

backend/API/Interfaces/IBondService.cs

@@ -9,6 +9,7 @@ public interface IBondService
     Task<List<Lockup>> GetAllLockups(bool ignoreCache = false);
     Task<List<LockEvent>> GetAllLockupEvents(bool ignoreCache = false);
     Task<List<ClaimEvent>> GetAllClaimEvents(bool ignoreCache = false);
+    Task<List<VoteEvent>> GetAllVoteEvents(bool ignoreCache = false);
     Task<Lockup> GetLockup(string lockupId, bool ignoreCache = false);
     Task<List<Lockup>> GetAccountLockups(string account, bool ignoreCache = false);
     Task<List<IBondEvent>> GetAllLockupsFromBond(string bondId, bool ignoreCache = false);

backend/API/Models/BondDashboard.cs

@@ -1,3 +1,5 @@
+using Dab.API.Models.Events;
+
 namespace Dab.API.Models.Dashboard;
 
 public class LockDTO
@@ -17,6 +19,17 @@ public LockDTO(EventDTO evt)
         RequestKey = evt.RequestKey;
         LockTime = DateTime.TryParse(evt.BlockTime, out var lockTime) ? lockTime : default;
     }
+
+    public LockDTO(LockEvent evt)
+    {
+        BondId = evt.BondId;
+        Account = evt.Account;
+        LockedAmount = evt.Amount;
+        MaxRewards = evt.Rewards;
+        RequestKey = evt.RequestKey;
+        LockTime = evt.Timestamp;
+    }
+
 }
 
 public class ClaimDTO
@@ -36,6 +49,16 @@ public ClaimDTO(EventDTO evt)
         RequestKey = evt.RequestKey;
         ClaimTime = DateTime.TryParse(evt.BlockTime, out var lockTime) ? lockTime : default;
     }
+    public ClaimDTO(ClaimEvent evt)
+    {
+        BondId = evt.BondId;
+        Account = evt.Account;
+        Amount = evt.OriginalAmount;
+        TotalAmount = evt.TotalAmount;
+        RequestKey = evt.RequestKey;
+        ClaimTime = evt.Timestamp;
+    }
+
 }
 
 public class PollVoteEventDTO
@@ -47,12 +70,21 @@ public class PollVoteEventDTO
     public string RequestKey { get; set; } = "";
     public PollVoteEventDTO(EventDTO evt)
     {
-        PollId = evt.Params[0]?.ToString();
-        Account = evt.Params[1]?.ToString();
+        PollId = evt.Params[1]?.ToString();
+        Account = evt.Params[0]?.ToString();
         Action = evt.Params[2]?.ToString();
         RequestKey = evt.RequestKey;
         VoteTime = DateTime.TryParse(evt.BlockTime, out var lockTime) ? lockTime : default;
     }
+    public PollVoteEventDTO(VoteEvent evt)
+    {
+        PollId = evt.PollId;
+        Account = evt.Account;
+        Action = evt.Action;
+        RequestKey = evt.RequestKey;
+        VoteTime = evt.Timestamp;
+    }
+
 }
 
 
@@ -84,6 +116,7 @@ public class BondDashboard
     public List<LockDTO> LatestLocks { get; set; } = new();
     public List<ClaimDTO> LatestClaims { get; set; } = new();
     public List<PollVoteEventDTO> LatestVotes { get; set; } = new();
+    public bool ActivePool {get; set;}
 }
 
 public class VoteDistributionDTO

backend/API/Models/Bonder.cs

@@ -4,8 +4,6 @@
 
 namespace Dab.API.Models.Bonder;
 
-//FIXME these types require more testing (not handled {decimal:})
-
 public class LockupOption
 {
     [JsonPropertyName("option-name")]

backend/API/Models/Cache.cs

@@ -77,6 +77,8 @@ public class CacheKeys
 
         public static string AllVotes() => $"all-votes";
 
+                public static string AllVoteEvents() => $"all-vote-events";
+
         public static string ApiAnalytics() => $"api-dashboard";
     }
 }

backend/API/Models/Events.cs

@@ -37,3 +37,12 @@ public class ClaimEvent : IBondEvent
 
     public decimal Amount => TotalAmount;
 }
+
+public class VoteEvent
+{
+    public string Account { get; set; } = "";
+    public string PollId { get; set; } = "";
+    public string Action { get; set; } = "";
+    public DateTime Timestamp { get; set; }
+    public string RequestKey { get; set; } = "";
+}

backend/API/Program.cs

@@ -98,7 +98,6 @@
 // Business logic services
 // builder.Services.AddSingleton<IDaoService, DaoService>();
 builder.Services.AddSingleton<IPactService, PactService>();
-builder.Services.AddSingleton<IChainwebDataRetriever, ChainwebDataRetriever>();
 builder.Services.AddSingleton<ChainwebGraphQLRetriever>();
 builder.Services.AddSingleton<IBondService, BondService>();
 builder.Services.AddSingleton<IPollService, PollService>();

backend/API/Services/AnalyticsService.cs

@@ -68,13 +68,9 @@ private async Task<List<EventDTO>> CacheEventSearch(string evt, bool ignoreCache
 
     public async Task<List<LockDTO>> GetLatestLocks(bool ignoreCache = false)
     {
-        var lockupsInContract = await _bondService.GetAllLockups();
-        if (!lockupsInContract.Any()) return new List<LockDTO>();
+        var lockupsInContract = await _bondService.GetAllLockupEvents();
 
-        var evt = $"{ns}.bonder.LOCK";
-        var query = await CacheEventSearch(evt, ignoreCache);
-
-        return query
+        return lockupsInContract
             .Select(evt => new LockDTO(evt))
             .OrderByDescending(dto => dto.LockTime)
             .Take(3)
@@ -83,13 +79,9 @@ public async Task<List<LockDTO>> GetLatestLocks(bool ignoreCache = false)
 
     public async Task<List<ClaimDTO>> GetLatestClaims(bool ignoreCache = false)
     {
-        var lockupsInContract = await _bondService.GetAllLockups();
-        if (!lockupsInContract.Any()) return new List<ClaimDTO>();
-
-        var evt = $"{ns}.bonder.CLAIM";
-        var query = await CacheEventSearch(evt, ignoreCache);
+        var claimsInContract = await _bondService.GetAllClaimEvents();
 
-        return query
+        return claimsInContract
             .Select(evt => new ClaimDTO(evt))
             .OrderByDescending(dto => dto.ClaimTime)
             .Take(3)
@@ -98,13 +90,9 @@ public async Task<List<ClaimDTO>> GetLatestClaims(bool ignoreCache = false)
 
     public async Task<List<PollVoteEventDTO>> GetLatestVotes(bool ignoreCache = false)
     {
-        var lockupsInContract = await _bondService.GetAllLockups();
-        if (!lockupsInContract.Any()) return new List<PollVoteEventDTO>();
-
-        var evt = $"{ns}.poller.VOTE";
-        var query = await CacheEventSearch(evt, ignoreCache);
+        var votesInContract = await _bondService.GetAllVoteEvents();
 
-        return query
+        return votesInContract
             .Select(evt => new PollVoteEventDTO(evt))
             .OrderByDescending(dto => dto.VoteTime)
             .Take(3)
@@ -240,7 +228,8 @@ public async Task<ServiceResult> GetApiAnalytics(bool ignoreCache = false)
                 MostVotedPoll = await SafeExecute(async () => await GetMostVotedPoll(ignoreCache), ""),
                 AverageLockup = await SafeExecute(async () => await GetAverageLockup(ignoreCache), ""),
                 MaxReturnRate = await SafeExecute(async () => await GetMaxReturnRate(ignoreCache), 0m),
-                TotalLockedAmount = await SafeExecute(async () => (await _bondService.GetAllLockupEvents(ignoreCache)).Sum(x => x.Amount + x.Rewards), 0m)
+                TotalLockedAmount = await SafeExecute(async () => (await _bondService.GetAllLockupEvents(ignoreCache)).Sum(x => x.Amount + x.Rewards), 0m),
+                ActivePool = await SafeExecute(async () => (await IsPollActive(ignoreCache)), false)
             };
 
             var jsonResult = Utils.JsonPrettify(ret);
@@ -268,6 +257,19 @@ private async Task<T> SafeExecute<T>(Func<Task<T>> func, T defaultValue)
         }
     }
 
+    private async Task<bool> IsPollActive(bool ignoreCache = false)
+    {
+
+        try
+        {
+            var pools = await _pollService.GetActivePolls(ignoreCache);
+            return pools.Any();
+        }
+        catch
+        {
+            return false;
+        }
+    }
 
     private async Task<decimal> GetGlobalGivenRewards(bool ignoreCache = false)
     {

backend/API/Services/BondService.cs

@@ -13,19 +13,17 @@ public class BondService : IBondService
     private readonly ILogger<BondService> _logger;
     private readonly ICacheService _cacheService;
     private readonly IPactService _pactService;
-    private readonly IChainwebDataRetriever _dataRetriever;
     private readonly ChainwebGraphQLRetriever _graphRetriever;
     private readonly DabContractConfig _dabConfig;
     private readonly string chain;
     private readonly string ns;
     private readonly int expirySeconds = 20;
 
-    public BondService(ILogger<BondService> logger, ICacheService cacheService, IPactService pactService, IConfiguration configuration, IChainwebDataRetriever dataRetriever, ChainwebGraphQLRetriever graphRetriever)
+    public BondService(ILogger<BondService> logger, ICacheService cacheService, IPactService pactService, IConfiguration configuration, ChainwebGraphQLRetriever graphRetriever)
     {
         _logger = logger;
         _cacheService = cacheService;
         _pactService = pactService;
-        _dataRetriever = dataRetriever;
         _graphRetriever = graphRetriever;
 
         _dabConfig = (configuration.GetSection("DabContractConfig").Get<DabContractConfig>() ??
@@ -34,47 +32,55 @@ public BondService(ILogger<BondService> logger, ICacheService cacheService, IPac
         ns = _dabConfig.Namespace;
     }
 
-public async Task<List<LockEvent>> GetAllLockupEvents(bool ignoreCache = false)
-{
-    // var locksInContract = await GetAllLockups(ignoreCache);
+    public async Task<List<LockEvent>> GetAllLockupEvents(bool ignoreCache = false)
+    {
+        var cacheKey = CacheKeys.AllLockupEvents();
+
+        if (!ignoreCache && await _cacheService.HasItem(cacheKey))
+        {
+            var cached = await _cacheService.GetItem<string>(cacheKey);
+            return JsonSerializer.Deserialize<List<LockEvent>>(cached) ?? new();
+        }
+
+        var lockEvents = (await _graphRetriever.RetrieveLockData())
+            .GroupBy(e => e.RequestKey)
+            .Select(g => g.First())
+            .ToList();
 
-    // if (!locksInContract.Any()) return new List<LockEvent>();
+        var ret = Utils.JsonPrettify(lockEvents);
 
-    var cacheKey = CacheKeys.AllLockupEvents();
+        await _cacheService.SetItem(cacheKey, ret, 30 * expirySeconds);
+        return lockEvents;
+    }
 
-    if (!ignoreCache && await _cacheService.HasItem(cacheKey))
+    public async Task<List<VoteEvent>> GetAllVoteEvents(bool ignoreCache = false)
     {
-        var cached = await _cacheService.GetItem<string>(cacheKey);
-        return JsonSerializer.Deserialize<List<LockEvent>>(cached) ?? new();
+        var cacheKey = CacheKeys.AllVoteEvents();
+
+        if (!ignoreCache && await _cacheService.HasItem(cacheKey))
+        {
+            var cached = await _cacheService.GetItem<string>(cacheKey);
+            return JsonSerializer.Deserialize<List<VoteEvent>>(cached) ?? new();
+        }
+
+        var voteEvents = (await _graphRetriever.RetrieveVoteData())
+            .GroupBy(e => e.RequestKey)
+            .Select(g => g.First())
+            .ToList();
+
+
+        var ret = Utils.JsonPrettify(voteEvents);
+
+        await _cacheService.SetItem(cacheKey, ret, 30 * expirySeconds);
+        return voteEvents;
     }
 
-    // Temporarily commented out
-    var lockEvents = await _graphRetriever.RetrieveLockData();
-
-    // var lockEvents = locksInContract.Select(lockup => new LockEvent
-    // {
-    //     BondId = lockup.BondId,
-    //     Account = lockup.Account,
-    //     Amount = lockup.KdaLocked,
-    //     Rewards = lockup.MaxKdaRewards,
-    //     LockupLength = lockup.LockupOption.OptionLength,
-    //     Timestamp = lockup.LockupStartTime.Date,
-    //     RequestKey = "", //lockup.LockupId,
-    //     Type = "Lock"
-    // }).ToList();
-
-    var ret = Utils.JsonPrettify(lockEvents);
-
-    await _cacheService.SetItem(cacheKey, ret, 30 * expirySeconds);
-    return lockEvents;
-}
 
 
 
     public async Task<List<ClaimEvent>> GetAllClaimEvents(bool ignoreCache = false)
     {
 
-
         var cacheKey = CacheKeys.AllClaimEvents();
 
         if (!ignoreCache && await _cacheService.HasItem(cacheKey))
@@ -83,7 +89,11 @@ public async Task<List<ClaimEvent>> GetAllClaimEvents(bool ignoreCache = false)
             return JsonSerializer.Deserialize<List<ClaimEvent>>(cached) ?? new();
         }
 
-        var claimEvents = await _graphRetriever.RetrieveClaimData();
+        var claimEvents = (await _graphRetriever.RetrieveClaimData())
+            .GroupBy(e => e.RequestKey)
+            .Select(g => g.First())
+            .ToList();
+
 
         var ret = Utils.JsonPrettify(claimEvents);