chore: fix tests

Author: vacekj

src/calculator/index.ts

@@ -280,41 +280,106 @@ export default class Calculator {
   /**
    * Estimates matching for a given project and potential additional votes
    * @param potentialVotes
+   * @param roundId
    */
   async estimateMatching(
-    potentialVotes: Vote[],
-    roundId: string,
-    roundToken: string
+    potentialVotes: PotentialVote[],
+    roundId: string
   ): Promise<MatchingEstimateResult[]> {
     const votes = await this.parseJSONFile<Vote>(
       "votes",
       `${this.chainId}/rounds/${this.roundId}/votes.json`
     );
 
+    const rounds = await this.parseJSONFile<Round>(
+      "rounds",
+      `${this.chainId}/rounds.json`
+    );
+
+    const round = rounds.find((r: Round) => r.id === this.roundId);
+
+    if (round === undefined) {
+      throw new ResourceNotFoundError("round");
+    }
+
+    if (round.matchAmount === undefined) {
+      throw new ResourceNotFoundError("round match amount");
+    }
+
+    if (round.token === undefined) {
+      throw new ResourceNotFoundError("round token");
+    }
+
+    const applications = await this.parseJSONFile<Application>(
+      "applications",
+      `${this.chainId}/rounds/${this.roundId}/applications.json`
+    );
+
     const currentResults = await this._calculate(votes);
+    const potentialVotesAugmented: Vote[] = await Promise.all(
+      potentialVotes.map(async (vote) => {
+        const { amount: amountUSD } = await this.priceProvider.convertToUSD(
+          this.chainId,
+          vote.token,
+          vote.amount
+        );
+
+        const { amount: amountRoundToken } =
+          await this.priceProvider.convertFromUSD(
+            this.chainId,
+            round.token,
+            amountUSD
+          );
+
+        /* Find the latest approved application */
+        const application = applications
+          .filter(
+            (application) =>
+              application.metadata?.application.recipient === vote.recipient
+          )
+          .filter((application) => application.status === "APPROVED")
+          .sort((a, b) => a.statusUpdatedAtBlock - b.statusUpdatedAtBlock)[0];
+        if (!application) {
+          throw "Couldn't find application for project";
+        }
+        return {
+          amount: vote.amount.toString(),
+          amountRoundToken: amountRoundToken.toString(),
+          amountUSD,
+          token: vote.token,
+          roundId: this.roundId,
+          voter: vote.contributor,
+          grantAddress: vote.recipient,
+          projectId: application.projectId,
+          id: "",
+          applicationId: application.id,
+        };
+      })
+    );
     const potentialResults = await this._calculate([
       ...votes,
-      ...potentialVotes,
+      ...potentialVotesAugmented,
     ]);
 
     const finalResults: MatchingEstimateResult[] = [];
 
-    for (const key in potentialResults) {
-      const potentialResult = potentialResults[key];
-      const currentResult = currentResults[key];
+    for (const potentialResult of potentialResults) {
+      const currentResult = currentResults.find(
+        (res) => res.applicationId === potentialResult.applicationId
+      );
 
       /* Subtracting undefined from a bigint would fail,
        * so we explicitly subtract 0 if it's undefined */
       const difference =
-        potentialResult.matched - (currentResult.matched ?? 0n);
+        potentialResult.matched - (currentResult?.matched ?? 0n);
       const differenceInUSD = await this.priceProvider.convertToUSD(
         this.chainId,
-        roundToken,
+        round.token,
         difference
       );
 
-      const recipient = potentialVotes.find(
-        (vote) => vote.applicationId == key
+      const recipient = potentialVotesAugmented.find(
+        (vote) => vote.applicationId === potentialResult.applicationId
       )?.grantAddress;
 
       /** Can be undefined, but spreading an undefined is a no-op, so it's okay here */

src/http/api/v1/matches.ts

@@ -113,8 +113,8 @@ export const createHandler = (config: HttpApiConfig): express.Router => {
     res.send(responseBody);
   }
 
-  router.post("/chains/:chainId/rounds/:roundId/estimate", (req, res) => {
-    return estimateMatchesHandler(req, res, 200);
+  router.post("/chains/:chainId/rounds/:roundId/estimate", async (req, res) => {
+    await estimateMatchesHandler(req, res, 200);
   });
 
   async function estimateMatchesHandler(
@@ -149,7 +149,7 @@ export const createHandler = (config: HttpApiConfig): express.Router => {
     };
 
     const calculator = new Calculator(calculatorOptions);
-    const matches = await calculator.estimateMatching(potentialVotes);
+    const matches = await calculator.estimateMatching(potentialVotes, roundId);
     const responseBody = JSON.stringify(matches, (_key, value) =>
       typeof value === "bigint" ? value.toString() : (value as unknown)
     );

src/http/app.ts

@@ -11,7 +11,6 @@ import { createHandler as createApiHandler } from "./api/v1/index.js";
 import { PriceProvider } from "../prices/provider.js";
 import { PassportProvider } from "../passport/index.js";
 import { DataProvider } from "../calculator/index.js";
-import bodyParser from "body-parser";
 import { Chain } from "../config.js";
 
 export interface HttpApiConfig {
@@ -32,10 +31,11 @@ interface HttpApi {
 
 export const createHttpApi = (config: HttpApiConfig): HttpApi => {
   const app = express();
-  const api = createApiHandler(config);
 
   app.use(cors());
-  app.use(bodyParser.json());
+  app.use(express.json());
+
+  const api = createApiHandler(config);
 
   app.use((_req, res, next) => {
     if (config.buildTag !== null) {

src/test/http/app.test.ts

@@ -16,6 +16,7 @@ import { Logger } from "pino";
 import { PotentialVotes } from "../../http/api/v1/matches.js";
 import { PassportScore } from "../../passport/index.js";
 import { Chain } from "../../config.js";
+import { constants } from "ethers";
 
 vi.spyOn(os, "hostname").mockReturnValue("dummy-hostname");
 
@@ -325,59 +326,93 @@ describe("server", () => {
         expect(resp.body).toEqual(expectedResults);
       });
 
-      test("should estimate matching with new votes for projects", async () => {
-        const expectedResults = {
-          "application-id-1": {
+      test.only("should estimate matching with new votes for projects", async () => {
+        const expectedResults = [
+          {
+            applicationId: "application-id-1",
             capOverflow: "0",
+            chainId: 1,
             contributionsCount: "4",
-            difference: "-171",
-            matched: "1189",
-            matchedWithoutCap: "1189",
+            difference: "0",
+            differenceInUSD: 0,
+            matched: "1360",
+            matchedUSD: 0,
+            matchedWithoutCap: "1360",
+            payoutAddress: "grant-address-1",
+            projectId: "project-id-1",
+            recipient: "grant-address-1",
+            roundId: "0x1234",
             sumOfSqrt: "70",
-            totalReceived: "1510",
+            totalReceived: "1500",
           },
-          "application-id-2": {
+          {
+            applicationId: "application-id-2",
             capOverflow: "0",
+            chainId: 1,
             contributionsCount: "8",
-            difference: "964",
-            matched: "3124",
-            matchedWithoutCap: "3124",
-            sumOfSqrt: "102",
-            totalReceived: "1500",
+            difference: "0",
+            differenceInUSD: 0,
+            matched: "2160",
+            matchedUSD: 0,
+            matchedWithoutCap: "2160",
+            payoutAddress: "grant-address-2",
+            projectId: "project-id-2",
+            recipient: "grant-address-2",
+            roundId: "0x1234",
+            sumOfSqrt: "80",
+            totalReceived: "1000",
           },
-          "application-id-3": {
+          {
+            applicationId: "application-id-3",
             capOverflow: "0",
+            chainId: 1,
             contributionsCount: "7",
-            difference: "-795",
-            matched: "5685",
-            matchedWithoutCap: "5685",
+            difference: "0",
+            differenceInUSD: 0,
+            matched: "6480",
+            matchedUSD: 0,
+            matchedWithoutCap: "6480",
+            payoutAddress: "grant-address-3",
+            projectId: "project-id-3",
+            recipient: "0x0000000000000000000000000000000000000000",
+            roundId: "0x1234",
             sumOfSqrt: "140",
             totalReceived: "3400",
           },
-        };
+        ];
 
         const potentialVotes: PotentialVotes = [
           {
             amount: 10n,
             contributor: "voter-1",
             recipient: "grant-address-1",
-            token: "0",
+            token: constants.AddressZero,
           },
           {
             amount: 500n,
             contributor: "voter-2",
             recipient: "grant-address-2",
-            token: "0",
+            token: constants.AddressZero,
           },
         ];
 
+        const replacer = (
+          _key: string,
+          value: bigint | string | number | object
+        ) => (typeof value === "bigint" ? value.toString() : value);
+
         const resp = await request(app)
           .post("/api/v1/chains/1/rounds/0x1234/estimate")
-          .send({
-            potentialVotes,
-          })
           .set("Content-Type", "application/json")
-          .set("Accept", "application/json");
+          .set("Accept", "application/json")
+          .send(
+            JSON.stringify(
+              {
+                potentialVotes,
+              },
+              replacer
+            )
+          );
         expect(resp.statusCode).toBe(200);
         expect(resp.body).toEqual(expectedResults);
       });