@merkl/api 0.10.133 → 0.10.135

package/dist/src/eden/index.d.ts

@@ -378,6 +378,31 @@ declare const eden: {
                     200: number;
                 }>>;
             };
+            aggregate: ((params: {
+                field: string | number;
+            }) => {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        sort?: undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        sum: File;
+                    };
+                }>>;
+            }) & {};
         };
         campaigns: {
             index: {
@@ -2215,6 +2240,38 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -4379,6 +4436,31 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: number;
                 }>>;
             };
+            aggregate: ((params: {
+                field: string | number;
+            }) => {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        sort?: undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: undefined;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        sum: File;
+                    };
+                }>>;
+            }) & {};
         };
         campaigns: {
             index: {

package/dist/src/index.d.ts

@@ -435,6 +435,38 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/libs/campaigns/campaignTypes/CompoundDynamicData.js

@@ -20,11 +20,13 @@ export async function CompoundDynamicData(_chainId, campaigns) {
                     target: campaign.campaignParameters.targetToken,
                 });
             }
-            calls.push({
-                allowFailure: true,
-                callData: CTokenInterface.encodeFunctionData("totalBorrows"),
-                target: campaign.campaignParameters.targetToken,
-            });
+            else {
+                calls.push({
+                    allowFailure: true,
+                    callData: CTokenInterface.encodeFunctionData("totalBorrows"),
+                    target: campaign.campaignParameters.targetToken,
+                });
+            }
         }
     }
     return {

package/dist/src/modules/v4/opportunity/opportunity.controller.d.ts

@@ -408,6 +408,38 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
             };
         };
     };
+} & {
+    opportunities: {
+        aggregate: {
+            ":field": {
+                get: {
+                    body: unknown;
+                    params: {
+                        field: never;
+                    };
+                    query: {
+                        sort?: undefined;
+                        name?: string | undefined;
+                        tokens?: string | undefined;
+                        status?: string | undefined;
+                        items?: number | undefined;
+                        tags?: string | undefined;
+                        chainId?: string | undefined;
+                        page?: number | undefined;
+                        action?: string | undefined;
+                        mainProtocolId?: string | undefined;
+                        order?: undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            sum: File;
+                        };
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/src/modules/v4/opportunity/opportunity.controller.js

@@ -1,7 +1,7 @@
 import { NotFoundError } from "../../../errors";
 import { AuthorizationHeadersDto, TokenAuthGuard } from "../../../guards/TokenAuth.guard";
 import Elysia from "elysia";
-import { CreateOpportunityDto, GetOpportunitiesQueryDto, OpportunityUniqueDto } from "./opportunity.model";
+import { CreateOpportunityDto, GetOpportunitiesQueryDto, OpportunityAggregateFieldDto, OpportunityUniqueDto, } from "./opportunity.model";
 import { OpportunityService } from "./opportunity.service";
 import { transformId } from "./transform-id.pipe";
 import { validateId } from "./validate-id.pipe";
@@ -60,4 +60,9 @@ export const OpportunityController = new Elysia({ prefix: "/opportunities", deta
     query: GetOpportunitiesQueryDto,
 })
     // ─── Get Opportunities Count ─────────────────────────────────────────
-    .get("/count", async ({ query }) => await OpportunityService.countMany(query), { query: GetOpportunitiesQueryDto });
+    .get("/count", async ({ query }) => await OpportunityService.countMany(query), { query: GetOpportunitiesQueryDto })
+    // ─── Get Aggregate fields  ─────────────────────────────────────────
+    .get("/aggregate/:field", async ({ query, params }) => await OpportunityService.aggregate(query, params.field), {
+    params: OpportunityAggregateFieldDto,
+    query: GetOpportunitiesQueryDto,
+});

package/dist/src/modules/v4/opportunity/opportunity.model.d.ts

@@ -107,7 +107,11 @@ export declare const CreateOpportunityDto: import("@sinclair/typebox").TObject<{
     protocols: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     mainProtocol: import("@sinclair/typebox").TString;
 }>;
+export declare const OpportunityAggregateFieldDto: import("@sinclair/typebox").TObject<{
+    field: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"dailyRewards">[]>;
+}>;
 export type GetOpportunitiesQueryEntity = typeof GetOpportunitiesQueryDto.static;
 export type CreateOpportunityModel = typeof CreateOpportunityDto.static & {
     id: string;
 };
+export type OpportunityAggregateField = typeof OpportunityAggregateFieldDto.static;

package/dist/src/modules/v4/opportunity/opportunity.model.js

@@ -34,3 +34,6 @@ export const CreateOpportunityDto = t.Object({
     protocols: t.Array(t.String()),
     mainProtocol: t.String(),
 });
+export const OpportunityAggregateFieldDto = t.Object({
+    field: t.Union(["dailyRewards"].map(v => t.Literal(v))),
+});

package/dist/src/modules/v4/opportunity/opportunity.repository.d.ts

@@ -1,4 +1,4 @@
-import type { Prisma, Status } from "../../../../database/api/.generated";
+import { type Prisma, Status } from "../../../../database/api/.generated";
 import { type AprRecord } from "../apr";
 import { type DailyRewardsRecord } from "../reward";
 import { type TvlRecord } from "../tvl";
@@ -462,18 +462,7 @@ export declare abstract class OpportunityRepository {
         apr: number;
         dailyRewards: number;
     }>;
-    static updateApr(id: string, apr: number): Promise<{
-        name: string;
-        type: import("../../../../database/api/.generated").$Enums.CampaignType;
-        id: string;
-        status: import("../../../../database/api/.generated").$Enums.Status;
-        tags: string[];
-        identifier: string;
-        chainId: number;
-        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
-        mainProtocolId: string | null;
-        tvl: number;
-        apr: number;
-        dailyRewards: number;
+    static aggregateSum(field: keyof Prisma.OpportunitySumAggregateInputType, query: GetOpportunitiesQueryEntity): Promise<{
+        sum: never;
     }>;
 }

package/dist/src/modules/v4/opportunity/opportunity.repository.js

@@ -1,4 +1,5 @@
 import { apiDbClient } from "../../../utils/prisma";
+import { Status } from "../../../../database/api/.generated";
 import { AprService } from "../apr";
 import { RewardService } from "../reward";
 import { TvlService } from "../tvl";
@@ -209,9 +210,18 @@ export class OpportunityRepository {
         };
     }
     static async updateStatus(id, status) {
+        if (status === Status.PAST)
+            return await apiDbClient.opportunity.update({ where: { id }, data: { status, apr: 0, dailyRewards: 0 } });
         return await apiDbClient.opportunity.update({ where: { id }, data: { status } });
     }
-    static async updateApr(id, apr) {
-        return await apiDbClient.opportunity.update({ where: { id }, data: { apr } });
+    static async aggregateSum(field, query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        const result = await apiDbClient.opportunity.aggregate({
+            _sum: {
+                [field]: true,
+            },
+            ...args,
+        });
+        return { sum: result._sum[field] ?? null };
     }
 }

package/dist/src/modules/v4/opportunity/opportunity.service.d.ts

@@ -1,4 +1,5 @@
 import { type CreateCampaignModel } from "../campaign";
+import { Prisma } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
 import type { CreateOpportunityModel, GetOpportunitiesQueryEntity, LightOpportunityFromDB, OpportunityMetadata, OpportunityUnique } from "./opportunity.model";
 import { OpportunityRepository } from "./opportunity.repository";
@@ -438,4 +439,7 @@ export declare abstract class OpportunityService {
         apr: number;
         dailyRewards: number;
     };
+    static aggregate(query: GetOpportunitiesQueryEntity, field: keyof Prisma.OpportunitySumAggregateInputType): Promise<{
+        sum: never;
+    }>;
 }

package/dist/src/modules/v4/opportunity/opportunity.service.js

@@ -84,7 +84,6 @@ export class OpportunityService {
             for (const opp of opportunities) {
                 const { live: activeCampaigns, soon: futureCampaigns } = CampaignService.splitOnStatus(opp.Campaigns);
                 if (activeCampaigns.length === 0) {
-                    await OpportunityRepository.updateApr(opp.id, 0);
                     await OpportunityRepository.updateStatus(opp.id, futureCampaigns.length === 0 ? "PAST" : "SOON").catch(err => log.error("Cannot update opportunity status to PAST", err, "opportunities"));
                 }
                 if (opp.status !== "LIVE" && activeCampaigns.length !== 0)
@@ -177,4 +176,7 @@ export class OpportunityService {
             protocol: MainProtocol ?? undefined,
         };
     }
+    static aggregate(query, field) {
+        return OpportunityRepository.aggregateSum(field, query);
+    }
 }

package/dist/src/modules/v4/router.d.ts

@@ -417,6 +417,38 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/ERC20Campaigns.d.ts

@@ -443,6 +443,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/blacklist.d.ts

@@ -441,6 +441,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/campaigns.d.ts

@@ -444,6 +444,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/campaignsInfo.d.ts

@@ -435,6 +435,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/multiChainPositions.d.ts

@@ -440,6 +440,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/opportunity.d.ts

@@ -458,6 +458,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {

package/dist/src/routes/v3/positions.d.ts

@@ -459,6 +459,38 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                ":field": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            field: never;
+                        };
+                        query: {
+                            sort?: undefined;
+                            name?: string | undefined;
+                            tokens?: string | undefined;
+                            status?: string | undefined;
+                            items?: number | undefined;
+                            tags?: string | undefined;
+                            chainId?: string | undefined;
+                            page?: number | undefined;
+                            action?: string | undefined;
+                            mainProtocolId?: string | undefined;
+                            order?: undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                sum: File;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {