[DEV-200] Implement voting power rest endpoint

apps/api-gateway/meshrc.ts

@@ -27,6 +27,16 @@ export default processConfig(
                 },
               },
               transforms: [
+                {
+                  filterSchema: {
+                    filters: [
+                      'Query.!{accountPower}',
+                      'Query.!{accountPowers}',
+                      'Query.!{votingPowerHistory}',
+                      'Query.!{votingPowerHistorys}'
+                    ]
+                  }
+                },
                 {
                   rename: {
                     renames: [
@@ -57,7 +67,7 @@ export default processConfig(
           ];
         }),
     ],
-    additionalTypeDefs:`
+    additionalTypeDefs: `
       type AverageDelegationPercentageItem {
         date: String!
         high: String!

apps/api-gateway/src/resolvers/item.ts

@@ -1,13 +1,11 @@
 const daoItemQueries = [
   "account",
   "accountBalance",
-  "accountPower",
   "daoMetricsDayBucket",
   "delegation",
   "proposalsOnchain",
   "transfer",
   "votesOnchain",
-  "votingPowerHistory",
 ];
 
 export const itemResolvers = daoItemQueries.reduce((acc, fieldName) => {

apps/api-gateway/src/resolvers/list.ts

@@ -1,15 +1,12 @@
-
 const daoListQueries = [
   'accountBalances',
-  'accountPowers',
   'accounts',
   'daoMetricsDayBuckets',
   'delegations',
   'proposalsOnchains',
   'tokens',
   'transfers',
   'votesOnchains',
-  'votingPowerHistorys',
 ]
 
 export const listResolvers = daoListQueries.reduce((acc, fieldName) => {

apps/api-gateway/src/resolvers/rest.ts

@@ -1,5 +1,6 @@
 const daoItemQueries = [
-  'accountInteractions',
+  "accountBalanceVariations",
+  "accountInteractions",
   "compareActiveSupply",
   "compareAverageTurnout",
   "compareCexSupply",
@@ -11,23 +12,24 @@ const daoItemQueries = [
   "compareTotalSupply",
   "compareTreasury",
   "compareVotes",
+  "dao",
+  "delegationPercentageByDay",
   "getTotalAssets",
   "getVotingPower",
-  "historicalTokenData",
-  "proposalsActivity",
   "historicalBalances",
-  "historicalVotingPower",
-  "proposals",
-  "transactions",
+  "historicalTokenData",
+  "historicalVotingPowers",
   "lastUpdate",
   "proposal",
-  "votingPowers",
   "proposalNonVoters",
+  "proposals",
+  "proposalsActivity",
   "token",
+  "transactions",
+  "votingPowerByAccountId",
   "votingPowerVariations",
-  "accountBalanceVariations",
-  "delegationPercentageByDay",
-  "dao",
+  "votingPowerVariationsByAccountId",
+  "votingPowers",
 ];
 
 export const restResolvers = daoItemQueries.reduce((acc, fieldName) => {

apps/indexer/src/api/controllers/account-balance/historical-balances.ts

@@ -2,16 +2,12 @@ import { isAddress } from "viem";
 import { OpenAPIHono as Hono, createRoute, z } from "@hono/zod-openapi";
 
 import { DaysOpts, DaysEnum, DaoIdEnum } from "@/lib/enums";
-import {
-  HistoricalBalancesService,
-  HistoricalVotingPowerService,
-} from "@/api/services";
+import { HistoricalBalancesService } from "@/api/services";
 import { HistoricalBalanceMapper } from "@/api/mappers";
 
 export function historicalBalances(
   app: Hono,
   daoId: DaoIdEnum,
-  votingPowerService: HistoricalVotingPowerService,
   balancesService: HistoricalBalancesService,
 ) {
   // Historical Balances endpoint
@@ -82,64 +78,4 @@ export function historicalBalances(
       );
     },
   );
-
-  // Historical Voting Power endpoint
-  app.openapi(
-    createRoute({
-      method: "get",
-      operationId: "historicalVotingPower",
-      path: "/historical-voting-power",
-      summary: "Get historical voting power",
-      description:
-        "Fetch historical voting power for multiple addresses at a specific time period using multicall",
-      tags: ["historical-onchain"],
-      request: {
-        query: z.object({
-          addresses: z
-            .array(z.string())
-            .min(1, "At least one address is required")
-            .refine((addresses) =>
-              addresses.every((address) => isAddress(address)),
-            )
-            .or(
-              z
-                .string()
-                .refine((addr) => isAddress(addr), "Invalid Ethereum address")
-                .transform((addr) => [addr]),
-            ),
-          days: z
-            .enum(DaysOpts)
-            .default("7d")
-            .transform((val) => DaysEnum[val]),
-          fromDate: z.coerce.number().optional(),
-        }),
-      },
-      responses: {
-        200: {
-          description: "Successfully retrieved historical voting power",
-          content: {
-            "application/json": {
-              schema: z.array(
-                z.object({
-                  address: z.string(),
-                  votingPower: z.string(),
-                }),
-              ),
-            },
-          },
-        },
-      },
-    }),
-    async (context) => {
-      const { addresses, days, fromDate } = context.req.valid("query");
-
-      const votingPowers = await votingPowerService.getHistoricalVotingPower(
-        addresses,
-        days,
-        fromDate || Math.floor(Date.now() / 1000),
-      );
-
-      return context.json(votingPowers);
-    },
-  );
 }

apps/indexer/src/api/controllers/voting-power/voting-powers.ts → apps/indexer/src/api/controllers/voting-power/historical.ts

@@ -2,29 +2,29 @@ import { OpenAPIHono as Hono, createRoute } from "@hono/zod-openapi";
 
 import { VotingPowerService } from "@/api/services";
 import {
-  VotingPowerResponseSchema,
-  VotingPowerRequestSchema,
-  VotingPowerMapper,
+  HistoricalVotingPowerResponseSchema,
+  HistoricalVotingPowerRequestSchema,
+  HistoricalVotingPowerMapper,
 } from "@/api/mappers";
 
-export function votingPower(app: Hono, service: VotingPowerService) {
+export function historicalVotingPowers(app: Hono, service: VotingPowerService) {
   app.openapi(
     createRoute({
       method: "get",
-      operationId: "votingPowers",
-      path: "/voting-powers",
+      operationId: "historicalVotingPowers",
+      path: "/voting-powers/historical",
       summary: "Get voting power changes",
       description: "Returns a list of voting power changes",
       tags: ["proposals"],
       request: {
-        query: VotingPowerRequestSchema,
+        query: HistoricalVotingPowerRequestSchema,
       },
       responses: {
         200: {
           description: "Successfully retrieved voting power changes",
           content: {
             "application/json": {
-              schema: VotingPowerResponseSchema,
+              schema: HistoricalVotingPowerResponseSchema,
             },
           },
         },
@@ -41,7 +41,7 @@ export function votingPower(app: Hono, service: VotingPowerService) {
         maxDelta,
       } = context.req.valid("query");
 
-      const { items, totalCount } = await service.getVotingPowers(
+      const { items, totalCount } = await service.getHistoricalVotingPowers(
         account,
         skip,
         limit,
@@ -50,7 +50,7 @@ export function votingPower(app: Hono, service: VotingPowerService) {
         minDelta,
         maxDelta,
       );
-      return context.json(VotingPowerMapper(items, totalCount));
+      return context.json(HistoricalVotingPowerMapper(items, totalCount));
     },
   );
 }

apps/indexer/src/api/controllers/voting-power/index.ts

@@ -1,2 +1,3 @@
-export * from "./voting-powers";
-export * from "./voting-power-variations";
+export * from "./historical";
+export * from "./variations";
+export * from "./listing";

apps/indexer/src/api/controllers/voting-power/listing.ts

@@ -0,0 +1,90 @@
+import { OpenAPIHono as Hono, createRoute, z } from "@hono/zod-openapi";
+import { VotingPowerService } from "@/api/services";
+import {
+  VotingPowersRequestSchema,
+  VotingPowersResponseSchema,
+  VotingPowersMapper,
+  VotingPowerResponseSchema,
+} from "@/api/mappers/";
+import { isAddress } from "viem";
+import { VotingPowerMapper } from "@/api/mappers/voting-power/voting-power-variations";
+
+export function votingPowers(app: Hono, service: VotingPowerService) {
+  app.openapi(
+    createRoute({
+      method: "get",
+      operationId: "votingPowers",
+      path: "/voting-powers",
+      summary: "Get voting powers",
+      description: "TODO",
+      tags: ["proposals"],
+      request: {
+        query: VotingPowersRequestSchema,
+      },
+      responses: {
+        200: {
+          description: "Successfully retrieved voting power changes",
+          content: {
+            "application/json": {
+              schema: VotingPowersResponseSchema,
+            },
+          },
+        },
+      },
+    }),
+    async (context) => {
+      const {
+        limit,
+        skip,
+        orderDirection,
+        addresses,
+        powerGreaterThan,
+        powerLessThan,
+      } = context.req.valid("query");
+
+      const { items, totalCount } = await service.getVotingPowers(
+        skip,
+        limit,
+        orderDirection,
+        {
+          minAmount: powerGreaterThan,
+          maxAmount: powerLessThan,
+        },
+        addresses,
+      );
+
+      return context.json(VotingPowersMapper(items, totalCount));
+    },
+  );
+
+  app.openapi(
+    createRoute({
+      method: "get",
+      operationId: "votingPowerByAccountId",
+      path: "/voting-powers/{accountId}",
+      summary: "TODO",
+      description: "TODO",
+      tags: ["proposals"],
+      request: {
+        params: z.object({
+          accountId: z.string().refine((addr) => isAddress(addr)),
+        }),
+      },
+      responses: {
+        200: {
+          description: "Successfully retrieved voting power changes",
+          content: {
+            "application/json": {
+              schema: VotingPowerResponseSchema,
+            },
+          },
+        },
+      },
+    }),
+    async (context) => {
+      const { accountId } = context.req.valid("param");
+      const result = await service.getVotingPowersByAccountId(accountId);
+      return context.json(VotingPowerMapper(result));
+    },
+  );
+}