@merkl/api 0.20.78 → 0.20.80

package/dist/src/engine/dynamicData/implementations/Clamm.js

@@ -875,6 +875,14 @@ export class ClammDynamicData {
                         ]);
                         const rewardToken = rewardTokens[0];
                         distributionMeanAPR = rewardToken.isPoint ? distributionMeanAPR / 365 / 100 : distributionMeanAPR;
+                        let poolBalanceToken0WithoutBlacklist = poolBalanceToken0 - (blacklistedBalance0 ?? 0);
+                        poolBalanceToken0WithoutBlacklist = !!poolBalanceToken0WithoutBlacklist
+                            ? poolBalanceToken0WithoutBlacklist
+                            : 0.00001;
+                        let poolBalanceToken1WithoutBlacklist = poolBalanceToken1 - (blacklistedBalance1 ?? 0);
+                        poolBalanceToken1WithoutBlacklist = !!poolBalanceToken1WithoutBlacklist
+                            ? poolBalanceToken1WithoutBlacklist
+                            : 0.00001;
                         dynamicData.push({
                             ...campaign,
                             amm: pool.amm,

package/dist/src/index.d.ts

@@ -148,7 +148,7 @@ declare const app: Elysia<"", false, {
         };
     };
 } & {
-    v4: {} | {
+    v4: {
         derive: {};
         resolve: {};
         schema: {};
@@ -2887,28 +2887,6 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
-    } & {
-        rewards: {
-            total: {
-                distributed: {
-                    "by-opportunities": {
-                        get: {
-                            body: unknown;
-                            params: {};
-                            query: {
-                                since: Date;
-                            };
-                            headers: {
-                                authorization: string;
-                            };
-                            response: {
-                                200: string;
-                            };
-                        };
-                    };
-                };
-            };
-        };
     } & {
         rewards: {
             total: {
@@ -3094,6 +3072,7 @@ declare const app: Elysia<"", false, {
                     };
                     response: {
                         200: {
+                            name: string;
                             Explorer: {
                                 id: string;
                                 type: import("@db/api").$Enums.ExplorerType;

package/dist/src/jobs/update-analytics.js

@@ -1,15 +1,258 @@
 import { CacheService } from "@/modules/v4/cache";
 import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { CampaignService } from "@/modules/v4/campaign";
+import { ChainService } from "@/modules/v4/chain/chain.service";
 import { RewardService } from "@/modules/v4/reward";
 import { log } from "@/utils/logger";
+import { Client } from "@notionhq/client";
+const notion = new Client({ auth: process.env.NOTION_TOKEN });
+const REWARDS_BY_PROTOCOLS_DATABASE_ID = "1cacfed0d48c80c288acc906291a91c8";
+const REWARDS_BY_CHAINS_DATABASE_ID = "1cacfed0d48c805bb300fa8ae5633a2d";
+const REWARDS_BY_TYPES_DATABASE_ID = "1cbcfed0d48c80d7bdedf45c133cbf63";
+const CAMPAIGNS_BY_CHAINS_DATABASE_ID = "1cbcfed0d48c8001b1ccf5c0900669ea";
+const CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID = "1cecfed0d48c8066b016f580e54a6b33";
+const CAMPAIGNS_BY_TYPES_DATABASE_ID = "1cecfed0d48c80dcb6bccf3ac3889b5b";
+const getCurrentMonthPages = async (databaseId, firstDayOfMonth) => {
+    const pagesToModify = await notion.databases.query({
+        database_id: databaseId,
+        filter: {
+            property: "From",
+            date: {
+                equals: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0],
+            },
+        },
+    });
+    return pagesToModify.results;
+};
 const main = async () => {
+    const chains = (await ChainService.findMany({})).reduce((prev, curr) => {
+        return Object.assign(prev, { [curr.id]: curr.name });
+    }, {});
     const today = new Date();
     const firstDayOfMonth = new Date(today.getFullYear(), today.getMonth(), 1).getTime() / 1000;
     const promises = [
-        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributed, firstDayOfMonth).then(() => log.info("Total Distributed cache updated successfully")),
-        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, firstDayOfMonth).then(() => log.info("Total Distributed by Chains cache updated successfully")),
-        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, firstDayOfMonth).then(() => log.info("Total Distributed by Type cache updated successfully")),
-        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByOpportunities, firstDayOfMonth).then(() => log.info("Total Distributed by Opportunities cache updated successfully")),
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, firstDayOfMonth).then(async (result) => {
+            const pagesToModify = await getCurrentMonthPages(REWARDS_BY_TYPES_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            if (today.getDate() === 1 || pagesToModify.length === 0) {
+                for (const [type, monthlyTotalRewards] of Object.entries(result)) {
+                    promises.push(notion.pages.create({
+                        parent: { type: "database_id", database_id: REWARDS_BY_TYPES_DATABASE_ID },
+                        properties: {
+                            Type: {
+                                type: "title",
+                                title: [{ type: "text", text: { content: type } }],
+                            },
+                            Rewards: { type: "number", number: monthlyTotalRewards },
+                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            else {
+                for (const page of pagesToModify) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Rewards: {
+                                type: "number",
+                                number: result[page.properties.Type
+                                    .title[0].text.content],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+                await Promise.all(promises);
+                log.info("Total Distributed by Type data pushed to Notion successfully");
+            }
+        }),
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, firstDayOfMonth).then(async (result) => {
+            const pagesToModify = await getCurrentMonthPages(REWARDS_BY_CHAINS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            if (today.getDate() === 1 || pagesToModify.length === 0) {
+                for (const [chain, monthlyTotalRewards] of Object.entries(result)) {
+                    promises.push(notion.pages.create({
+                        parent: { type: "database_id", database_id: REWARDS_BY_CHAINS_DATABASE_ID },
+                        properties: {
+                            Chains: {
+                                type: "title",
+                                title: [{ type: "text", text: { content: chains[chain] } }],
+                            },
+                            Rewards: { type: "number", number: monthlyTotalRewards },
+                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            else {
+                for (const page of pagesToModify) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Rewards: {
+                                type: "number",
+                                number: result[Object.keys(chains).find(key => page.properties.Chains.title[0].text.content === chains[key])],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+                await Promise.all(promises);
+                log.info("Total Distributed by Chains data pushed to Notion successfully");
+            }
+        }),
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByProtocol, firstDayOfMonth).then(async (result) => {
+            const pagesToModify = await getCurrentMonthPages(REWARDS_BY_PROTOCOLS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            if (today.getDate() === 1 || pagesToModify.length === 0) {
+                for (const [protocol, monthlyTotalRewards] of Object.entries(result)) {
+                    promises.push(notion.pages.create({
+                        parent: { type: "database_id", database_id: REWARDS_BY_PROTOCOLS_DATABASE_ID },
+                        properties: {
+                            Protocols: { type: "title", title: [{ type: "text", text: { content: protocol } }] },
+                            Rewards: { type: "number", number: monthlyTotalRewards },
+                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            else {
+                for (const page of pagesToModify) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Rewards: {
+                                type: "number",
+                                number: result[page.properties.Protocols.title[0].text.content],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            await Promise.all(promises);
+            log.info("Total Distributed by Protocols data pushed to Notion successfully");
+        }),
+        // ─── Campaigns ───────────────────────────────────────────────
+        CacheService.set(TTLPresets.DAY_1, CampaignService.countByChains, {
+            createdAfter: new Date(firstDayOfMonth * 1000),
+        }).then(async (result) => {
+            const pagesToModify = await getCurrentMonthPages(CAMPAIGNS_BY_CHAINS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            if (today.getDate() === 1 || pagesToModify.length === 0) {
+                for (const [chain, monthlyTotalCampaigns] of Object.entries(result)) {
+                    promises.push(notion.pages.create({
+                        parent: { type: "database_id", database_id: CAMPAIGNS_BY_CHAINS_DATABASE_ID },
+                        properties: {
+                            Chains: {
+                                type: "title",
+                                title: [{ type: "text", text: { content: chains[chain] } }],
+                            },
+                            Campaigns: { type: "number", number: monthlyTotalCampaigns },
+                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            else {
+                for (const page of pagesToModify) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Campaigns: {
+                                type: "number",
+                                number: result[Object.keys(chains).find(key => page.properties.Chains.title[0].text.content === chains[key])],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            await Promise.all(promises);
+            log.info("Campaigns by Chains data pushed to Notion successfully");
+        }),
+        CacheService.set(TTLPresets.DAY_1, CampaignService.countByProtocols, {
+            createdAfter: new Date(firstDayOfMonth * 1000),
+        }).then(async (result) => {
+            const pagesToModify = await getCurrentMonthPages(CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            if (today.getDate() === 1 || pagesToModify.length === 0) {
+                for (const [protocol, monthlyTotalCampaigns] of Object.entries(result)) {
+                    promises.push(notion.pages.create({
+                        parent: { type: "database_id", database_id: CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID },
+                        properties: {
+                            Protocols: {
+                                type: "title",
+                                title: [{ type: "text", text: { content: protocol } }],
+                            },
+                            Campaigns: { type: "number", number: monthlyTotalCampaigns },
+                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            else {
+                for (const page of pagesToModify) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Campaigns: {
+                                type: "number",
+                                number: result[page.properties.Protocols.title[0].text.content],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            await Promise.all(promises);
+            log.info("Campaigns by Protocols data pushed to Notion successfully");
+        }),
+        CacheService.set(TTLPresets.DAY_1, CampaignService.countByTypes, {
+            createdAfter: new Date(firstDayOfMonth * 1000),
+        }).then(async (result) => {
+            const pagesToModify = await getCurrentMonthPages(CAMPAIGNS_BY_TYPES_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            if (today.getDate() === 1 || pagesToModify.length === 0) {
+                for (const [type, monthlyTotalCampaigns] of Object.entries(result)) {
+                    promises.push(notion.pages.create({
+                        parent: { type: "database_id", database_id: CAMPAIGNS_BY_TYPES_DATABASE_ID },
+                        properties: {
+                            Types: {
+                                type: "title",
+                                title: [{ type: "text", text: { content: type } }],
+                            },
+                            Campaigns: { type: "number", number: monthlyTotalCampaigns },
+                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            else {
+                for (const page of pagesToModify) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Campaigns: {
+                                type: "number",
+                                number: result[page.properties.Types
+                                    .title[0].text.content],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+            }
+            await Promise.all(promises);
+            log.info("Campaigns by Types data pushed to Notion successfully");
+        }),
     ];
     await Promise.all(promises);
 };

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

@@ -1,62 +1,13 @@
 import { REDIS_READ_TIMEOUT, REDIS_RETRIES, REDIS_WRITE_TIMEOUT, redisClient } from "@/cache/redis";
-import { record } from "@elysiajs/opentelemetry";
 import { withRetry, withTimeout } from "@sdk";
 export class CacheRepository {
     static async set(ttl, key, value) {
-        await record("redis.set", async (span) => {
-            span.setAttribute("db.system", "redis");
-            span.setAttribute("net.transport", "ip_tcp");
-            span.setAttribute("db.statement", `set ${key} ${value} ${ttl}`);
-            const startTime = Date.now();
-            try {
-                const result = await withRetry(withTimeout, [redisClient.set(key, value, { EX: ttl }), REDIS_WRITE_TIMEOUT], REDIS_RETRIES);
-                span.setAttribute("db.redis.response_time", Date.now() - startTime);
-                return result;
-            }
-            catch (error) {
-                span.setStatus({ code: 2 }); // OpenTelemetry StatusCode.ERROR
-                span.setAttribute("error.message", error.message);
-                span.recordException(error);
-                throw error;
-            }
-        });
+        await withRetry(withTimeout, [redisClient.set(key, value, { EX: ttl }), REDIS_WRITE_TIMEOUT], REDIS_RETRIES);
     }
     static async ttl(key) {
-        return await record("redis.ttl", async (span) => {
-            span.setAttribute("db.system", "redis");
-            span.setAttribute("net.transport", "ip_tcp");
-            span.setAttribute("db.statement", `get ${key}`);
-            const startTime = Date.now();
-            try {
-                const result = await withRetry(withTimeout, [redisClient.ttl(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
-                span.setAttribute("db.redis.response_time", Date.now() - startTime);
-                return result;
-            }
-            catch (error) {
-                span.setStatus({ code: 2 }); // OpenTelemetry StatusCode.ERROR
-                span.setAttribute("error.message", error.message);
-                span.recordException(error);
-                throw error;
-            }
-        });
+        return await withRetry(withTimeout, [redisClient.ttl(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
     }
     static async get(key) {
-        return await record("redis.get", async (span) => {
-            span.setAttribute("db.system", "redis");
-            span.setAttribute("net.transport", "ip_tcp");
-            span.setAttribute("db.statement", `get ${key}`);
-            const startTime = Date.now();
-            try {
-                const result = await withRetry(withTimeout, [redisClient.get(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
-                span.setAttribute("db.redis.response_time", Date.now() - startTime);
-                return result;
-            }
-            catch (error) {
-                span.setStatus({ code: 2 }); // OpenTelemetry StatusCode.ERROR
-                span.setAttribute("error.message", error.message);
-                span.recordException(error);
-                throw error;
-            }
-        });
+        return await withRetry(withTimeout, [redisClient.get(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
     }
 }

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

@@ -152,5 +152,5 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     detail: { hide: true },
 })
     .get("count/by-chains", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByChains, query))
-    .get("/count/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByType, query))
-    .get("/count/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByProtocol, query));
+    .get("/count/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByTypes, query))
+    .get("/count/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, CampaignService.countByProtocols, query));

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

@@ -346,7 +346,7 @@ export declare abstract class CampaignService {
         opportunityId: string;
     }[]>>;
     static countByChains(query: GetCampaignQueryModel): Promise<Record<string, number>>;
-    static findAndGroupByType(query: GetCampaignQueryModel): Promise<Map<string, {
+    static findAndGroupByTypes(query: GetCampaignQueryModel): Promise<Map<string, {
         params: any;
         chain: {
             id: number;
@@ -419,8 +419,8 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
     }[]>>;
-    static countByType(query: GetCampaignQueryModel): Promise<Record<string, number>>;
-    static findAndGroupByProtocol(query: GetCampaignQueryModel): Promise<Map<string | null, {
+    static countByTypes(query: GetCampaignQueryModel): Promise<Record<string, number>>;
+    static findAndGroupByProtocols(query: GetCampaignQueryModel): Promise<Map<string | null, {
         params: any;
         chain: {
             id: number;
@@ -493,7 +493,7 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
     }[]>>;
-    static countByProtocol(query: GetCampaignQueryModel): Promise<Record<string, number>>;
+    static countByProtocols(query: GetCampaignQueryModel): Promise<Record<string, number>>;
     static countBy<T>(campaignsMap: Map<T, ReturnType<(typeof CampaignService)["format"]>[]>): Record<string, number>;
     /**
      * Counts the number of campaigns that complies to query

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

@@ -138,17 +138,17 @@ export class CampaignService {
     static async countByChains(query) {
         return CampaignService.countBy(await CampaignService.findAndGroupByChains({ ...query, items: 0 }));
     }
-    static async findAndGroupByType(query) {
+    static async findAndGroupByTypes(query) {
         return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.type);
     }
-    static async countByType(query) {
-        return CampaignService.countBy(await CampaignService.findAndGroupByType({ ...query, items: 0 }));
+    static async countByTypes(query) {
+        return CampaignService.countBy(await CampaignService.findAndGroupByTypes({ ...query, items: 0 }));
     }
-    static async findAndGroupByProtocol(query) {
-        return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.Opportunity.mainProtocolId);
+    static async findAndGroupByProtocols(query) {
+        return Map.groupBy(await CampaignService.findMany({ ...query, withOpportunity: true }), campaign => campaign.Opportunity.mainProtocolId);
     }
-    static async countByProtocol(query) {
-        return CampaignService.countBy(await CampaignService.findAndGroupByType({ ...query, items: 0 }));
+    static async countByProtocols(query) {
+        return CampaignService.countBy(await CampaignService.findAndGroupByProtocols({ ...query, items: 0 }));
     }
     static countBy(campaignsMap) {
         const count = {};

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

@@ -125,6 +125,7 @@ export declare const ChainController: Elysia<"/chains", false, {
                 };
                 response: {
                     200: {
+                        name: string;
                         Explorer: {
                             id: string;
                             type: import("@db/api").$Enums.ExplorerType;

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

@@ -63,6 +63,7 @@ export declare class ChainRepository {
      * @returns
      */
     static create(data: CreateChainModel): Promise<{
+        name: string;
         Explorer: {
             id: string;
             type: import("@db/api").$Enums.ExplorerType;
@@ -71,6 +72,7 @@ export declare class ChainRepository {
         }[];
     }>;
     static findUniqueOrThrow(id: number): Promise<{
+        name: string;
         Explorer: {
             id: string;
             type: import("@db/api").$Enums.ExplorerType;

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

@@ -64,6 +64,7 @@ export class ChainRepository {
             },
             select: {
                 Explorer: true,
+                name: true,
             },
         });
     }

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

@@ -35,6 +35,7 @@ export declare abstract class ChainService {
      */
     static getSupportedIds(): Promise<number[]>;
     static create(chain: CreateChainModel): Promise<{
+        name: string;
         Explorer: {
             id: string;
             type: import("@db/api").$Enums.ExplorerType;
@@ -52,4 +53,5 @@ export declare abstract class ChainService {
         name: string;
         icon: string;
     }>;
+    static getName(id: number): Promise<string>;
 }

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

@@ -47,4 +47,7 @@ export class ChainService {
     static async updateDailyRewards(id, dailyRewards) {
         return await ChainRepository.update(id, { dailyRewards });
     }
+    static async getName(id) {
+        return (await ChainRepository.findUniqueOrThrow(id)).name;
+    }
 }

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

@@ -1,4 +1,4 @@
+import { TracerService } from "@/modules/v4/tracer/tracer.service";
 import { ChainInteractionService } from "@sdk";
-import { TracerService } from "../tracer";
 const ChainInteractionServiceWrapper = TracerService.createTracedProxy(ChainInteractionService, "ChainInteractionService");
 export { ChainInteractionServiceWrapper as ChainInteractionService };

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

@@ -1,14 +1,14 @@
 import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { HttpError } from "@/errors";
+import { OpportunityRepository } from "@/modules/v4/opportunity/opportunity.repository";
 import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
+import { RewardService } from "@/modules/v4/reward/reward.service";
+import { TvlService } from "@/modules/v4/tvl/tvl.service";
 import bigintToString from "@/utils/bigintToString";
 import { log } from "@/utils/logger";
 import { Campaign, NETWORK_LABELS } from "@sdk";
 import { Campaign as CampaignEnum } from "@sdk";
 import { AprService } from "../apr";
-import { OpportunityRepository } from "../opportunity/opportunity.repository";
-import { RewardService } from "../reward";
-import { TvlService } from "../tvl";
 export class DynamicDataService {
     static async queryERC20DynamicData(chainId, tokenAddress, rewardTokenAddress, symbolRewardToken, decimals = 18) {
         const campaigns = [

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

@@ -1,9 +1,9 @@
+import type { AprRecord } from "@/modules/v4/apr/apr.model";
+import type { Campaign } from "@/modules/v4/campaign/campaign.model";
+import { type DailyRewardsRecord } from "@/modules/v4/reward";
+import type { TvlRecord } from "@/modules/v4/tvl/tvl.model";
 import { type Prisma, Status } from "@db/api";
 import type { MerklChainId } from "@sdk";
-import { type AprRecord } from "../apr";
-import type { Campaign } from "../campaign";
-import { type DailyRewardsRecord } from "../reward";
-import { type TvlRecord } from "../tvl";
 import type { CreateOpportunityModel, GetOpportunitiesQueryModel, Opportunity } from "./opportunity.model";
 export declare abstract class OpportunityRepository {
     #private;

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

@@ -1,11 +1,11 @@
+import { AprService } from "@/modules/v4/apr/apr.service";
 import { ProtocolService } from "@/modules/v4/protocol/protocol.service";
+import { RewardService } from "@/modules/v4/reward";
+import { TvlService } from "@/modules/v4/tvl/tvl.service";
 import { log } from "@/utils/logger";
 import { apiDbClient } from "@db";
 import { Status } from "@db/api";
 import moment from "moment";
-import { AprService } from "../apr";
-import { RewardService } from "../reward";
-import { TvlService } from "../tvl";
 export class OpportunityRepository {
     // ─── Utils ───────────────────────────────────────────────────────────
     static #transformQueryToPrismaFilters(query) {

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

@@ -347,28 +347,6 @@ export declare const RewardController: Elysia<"/rewards", false, {
             };
         };
     };
-} & {
-    rewards: {
-        total: {
-            distributed: {
-                "by-opportunities": {
-                    get: {
-                        body: unknown;
-                        params: {};
-                        query: {
-                            since: Date;
-                        };
-                        headers: {
-                            authorization: string;
-                        };
-                        response: {
-                            200: string;
-                        };
-                    };
-                };
-            };
-        };
-    };
 } & {
     rewards: {
         total: {

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

@@ -3,7 +3,6 @@ import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
 import { ChainDto } from "@/modules/v4/accounting/accounting.model";
 import { CampaignService } from "@/modules/v4/campaign/campaign.service";
 import { TokenService } from "@/modules/v4/token/token.service";
-import bigintToString from "@/utils/bigintToString";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
 import Elysia, { t } from "elysia";
 import { CacheService } from "../cache";
@@ -132,7 +131,6 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
     detail: { hide: true },
 })
     .get("/total/distributed", async ({ query }) => await RewardService.getTotalDistributed(query.since.getTime() / 1000))
-    .get("/total/distributed/by-opportunities", async ({ query }) => JSON.stringify(bigintToString(Array.from((await RewardService.getTotalDistributedByOpportunities(query.since.getTime() / 1000)).entries()))))
     .get("/total/distributed/by-chains", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, query.since.getTime() / 1000))
     .get("/total/distributed/by-types", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, query.since.getTime() / 1000))
     .get("/total/distributed/by-protocols", async ({ query }) => await CacheService.wrap(TTLPresets.DAY_1, RewardService.getTotalDistributedByProtocol, query.since.getTime() / 1000));