@merkl/api 0.20.88 → 0.20.90

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

@@ -1123,7 +1123,7 @@ declare const eden: {
                     query?: Record<string, unknown> | undefined;
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: unknown[];
+                    200: unknown[] | undefined;
                 }>>;
             };
         }) & {
@@ -1526,7 +1526,7 @@ declare const eden: {
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: unknown[];
+                        200: unknown[] | undefined;
                     }>>;
                 };
             }) & {
@@ -1539,7 +1539,7 @@ declare const eden: {
                             query?: Record<string, unknown> | undefined;
                             fetch?: RequestInit | undefined;
                         }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         }>>;
                     };
                     post: (body: {
@@ -1562,7 +1562,7 @@ declare const eden: {
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: unknown[];
+                        200: unknown[] | undefined;
                     }>>;
                 };
                 metadata: {
@@ -2741,6 +2741,7 @@ declare const eden: {
                             test?: boolean | undefined;
                             chainIds?: number[] | undefined;
                             reloadChainId?: number | undefined;
+                            claimableOnly?: boolean | undefined;
                         };
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -2849,6 +2850,7 @@ declare const eden: {
                     query: {
                         test?: boolean | undefined;
                         reloadChainId?: number | undefined;
+                        claimableOnly?: boolean | undefined;
                         chainId: number[];
                     };
                     fetch?: RequestInit | undefined;
@@ -6063,7 +6065,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -6630,7 +6632,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 authorization: string;
                             };
                             response: {
-                                200: unknown[];
+                                200: unknown[] | undefined;
                             };
                         };
                     };
@@ -6648,7 +6650,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 authorization: string;
                             };
                             response: {
-                                200: unknown[];
+                                200: unknown[] | undefined;
                             };
                         };
                     };
@@ -6678,7 +6680,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -8190,6 +8192,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 test?: boolean | undefined;
                                 chainIds?: number[] | undefined;
                                 reloadChainId?: number | undefined;
+                                claimableOnly?: boolean | undefined;
                             };
                             headers: unknown;
                             response: {
@@ -8309,6 +8312,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         query: {
                             test?: boolean | undefined;
                             reloadChainId?: number | undefined;
+                            claimableOnly?: boolean | undefined;
                             chainId: number[];
                         };
                         headers: unknown;
@@ -11800,7 +11804,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query?: Record<string, unknown> | undefined;
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: unknown[];
+                    200: unknown[] | undefined;
                 }>>;
             };
         }) & {
@@ -12203,7 +12207,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: unknown[];
+                        200: unknown[] | undefined;
                     }>>;
                 };
             }) & {
@@ -12216,7 +12220,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             query?: Record<string, unknown> | undefined;
                             fetch?: RequestInit | undefined;
                         }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         }>>;
                     };
                     post: (body: {
@@ -12239,7 +12243,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: unknown[];
+                        200: unknown[] | undefined;
                     }>>;
                 };
                 metadata: {
@@ -13418,6 +13422,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             test?: boolean | undefined;
                             chainIds?: number[] | undefined;
                             reloadChainId?: number | undefined;
+                            claimableOnly?: boolean | undefined;
                         };
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
@@ -13526,6 +13531,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query: {
                         test?: boolean | undefined;
                         reloadChainId?: number | undefined;
+                        claimableOnly?: boolean | undefined;
                         chainId: number[];
                     };
                     fetch?: RequestInit | undefined;

package/dist/src/engine/campaignTVL/factory.d.ts

@@ -0,0 +1,3 @@
+import type { Campaign } from "@sdk";
+import type { CampaignTVLBuilder } from "./interface";
+export declare const campaignDynamicDataBuilderFactory: (campaignType: Campaign) => CampaignTVLBuilder<Campaign> | null;

package/dist/src/engine/campaignTVL/factory.js

@@ -0,0 +1,9 @@
+// @dev Casts are made to enforce type safety
+// @dev A type error must be thrown if a new campaign type is added and the corresponding builder is not implemented
+const map = {};
+export const campaignDynamicDataBuilderFactory = (campaignType) => {
+    if (!map[campaignType]) {
+        return null;
+    }
+    return map[campaignType];
+};

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

@@ -75,16 +75,23 @@ export class EventBasedDynamicData {
                 const isLive = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
                 let distributionMeanAPR = 0;
                 const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+                const rewardTokens = await TokenService.findManyOrCreate([
+                    { chainId: campaign.chainId, address: campaign.rewardToken },
+                ]);
+                const rewardToken = rewardTokens[0];
                 const tvl = distributedRewards / multiplier;
                 if (isLive) {
                     /** Yearly rewards in $ */
-                    const fixRewardRate = multiplier * priceRewardToken;
-                    distributionMeanAPR = fixRewardRate;
+                    let fixRewardRate = multiplier * priceRewardToken;
                     if (distributedRewards > (amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp)) {
-                        distributionMeanAPR =
+                        fixRewardRate =
                             (fixRewardRate * amount * (moment().unix() - startTimestamp)) / (endTimestamp - startTimestamp) / tvl;
                     }
+                    distributionMeanAPR = fixRewardRate * 365 * 100;
                     distributionMeanAPR = !distributionMeanAPR || Number.isNaN(distributionMeanAPR) ? 0 : distributionMeanAPR;
+                    if (rewardToken.isPoint) {
+                        distributionMeanAPR = distributionMeanAPR / 365 / 100;
+                    }
                     dynamicData.push({
                         ...campaign,
                         apr: distributionMeanAPR,

package/dist/src/errors/InvalidParameter.error.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from "./HttpError";
+export declare class InvalidParameter extends HttpError {
+    constructor(message?: string);
+}

package/dist/src/errors/InvalidParameter.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class InvalidParameter extends HttpError {
+    constructor(message = "Invalid Parameter") {
+        super(message, 400);
+        this.name = "InvalidParameterError";
+    }
+}

package/dist/src/index.d.ts

@@ -1327,7 +1327,7 @@ declare const app: Elysia<"", false, {
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -1894,7 +1894,7 @@ declare const app: Elysia<"", false, {
                                 authorization: string;
                             };
                             response: {
-                                200: unknown[];
+                                200: unknown[] | undefined;
                             };
                         };
                     };
@@ -1912,7 +1912,7 @@ declare const app: Elysia<"", false, {
                                 authorization: string;
                             };
                             response: {
-                                200: unknown[];
+                                200: unknown[] | undefined;
                             };
                         };
                     };
@@ -1942,7 +1942,7 @@ declare const app: Elysia<"", false, {
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -3454,6 +3454,7 @@ declare const app: Elysia<"", false, {
                                 test?: boolean | undefined;
                                 chainIds?: number[] | undefined;
                                 reloadChainId?: number | undefined;
+                                claimableOnly?: boolean | undefined;
                             };
                             headers: unknown;
                             response: {
@@ -3573,6 +3574,7 @@ declare const app: Elysia<"", false, {
                         query: {
                             test?: boolean | undefined;
                             reloadChainId?: number | undefined;
+                            claimableOnly?: boolean | undefined;
                             chainId: number[];
                         };
                         headers: unknown;

package/dist/src/jobs/dynamic-data.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 /**
-@deprecated Used only for the v3/campaigns route
+  @deprecated Used only for the v3/campaigns route
  */
 import { Redis } from "@/cache";
 import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
@@ -19,6 +19,12 @@ if (!chainId)
 const queryCampaignTypes = process.env.CAMPAIGN_TYPES ? JSON.parse(process.env.CAMPAIGN_TYPES) : [];
 const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
 export const main = async () => {
+    await OpportunityConvertorService.logKeyAndTTLV3Opportunities(false, false, undefined, undefined);
+    await OpportunityConvertorService.setV3Opportunities(false, false, undefined, undefined);
+    log.info("✅ opportunity v3 cache updated successfully");
+    await OpportunityConvertorService.logKeyAndTTLV3Opportunities(false, true, undefined, undefined);
+    await OpportunityConvertorService.setV3Opportunities(false, true, undefined, undefined);
+    log.info("✅ opportunity v3 test cache updated successfully");
     let success = true;
     try {
         await Redis.safeSet(`MerklChainData_${chainId}`, await merklChainData(chainId));

package/dist/src/jobs/update-dynamic-data.js

@@ -1,6 +1,8 @@
 import { CampaignService } from "@/modules/v4/campaign";
 import { DynamicDataService } from "@/modules/v4/dynamicData/dynamicData.service";
 import { OpportunityService } from "@/modules/v4/opportunity";
+import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
+import { logger } from "@/utils/logger";
 import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
 // ─── Required Env Variables ──────────────────────────────────────────────────
@@ -9,24 +11,6 @@ if (!chainId)
     throw new Error("Environment variable CHAIN_ID is required.");
 // ─── Update Dynamic Data (APR / TVL / Daily Rewards) ─────────────────────────
 const main = async () => {
-    const liveCampaigns = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => {
-        return {
-            amount: c.amount,
-            campaignId: c.campaignId,
-            mainParameter: c.Opportunity.identifier,
-            campaignParameters: c.params,
-            campaignSubType: c.subType,
-            campaignType: CampaignEnum[c.type],
-            chainId: c.distributionChainId,
-            computeChainId: c.computeChainId,
-            creator: c.creatorAddress,
-            endTimestamp: Number(c.endTimestamp),
-            rewardToken: c.RewardToken.address,
-            startTimestamp: Number(c.startTimestamp),
-            index: 0,
-        };
-    });
-    await DynamicDataService.updateForCampaigns(liveCampaigns);
     // Update status of opportunities
     // 1. Get current live opportunities or opportunities with live campaigns
     const liveOpportunities = await OpportunityService.findLiveWithCampaigns(chainId);
@@ -48,15 +32,27 @@ const main = async () => {
         }
         if (status === "PAST" && (opportunity.apr !== 0 || opportunity.dailyRewards !== 0))
             await OpportunityService.update(opportunity.id, { status, apr: 0, dailyRewards: 0 });
-        if (opportunity.status !== status)
+        if (opportunity.status !== status) {
             await OpportunityService.update(opportunity.id, { status });
+        }
     }
     // 3. Update the status of the opportunities associated to future campaigns
-    const futureOpportunityIds = (await CampaignService.getFutureCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    const futureOpportunities = await CampaignService.getFutureCampaigns({ computeChainId: chainId });
     const liveOpportunityIds = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
-    await OpportunityService.updateMany(futureOpportunityIds?.filter(opportunityId => !liveOpportunityIds.includes(opportunityId)), { status: "SOON" });
+    const idToUpdate = futureOpportunities
+        ?.filter(c => !liveOpportunityIds.includes(c.id) && c.Opportunity.status !== "SOON")
+        .map(c => c.Opportunity.id);
+    if (idToUpdate.length > 0) {
+        await OpportunityService.updateMany(idToUpdate, { status: "SOON" });
+        logger.info(`updated ${idToUpdate.length} opportunities to SOON status.`);
+    }
     // 4. Update the status of the opportunities associated to live campaigns
     await OpportunityService.updateMany(liveOpportunityIds, { status: "LIVE" });
+    // 5. Update records for all live campaigns
+    const liveCampaigns = (await CampaignService.findMany({ chainId, status: "LIVE", test: true, withOpportunity: true })).map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], campaign, campaign.Opportunity.identifier));
+    for (const type of new Set(liveCampaigns.map(c => c.campaignType))) {
+        await DynamicDataService.update(chainId, type, liveCampaigns.filter(c => c.campaignType === type));
+    }
 };
 try {
     await main();

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

@@ -2,5 +2,8 @@ import { type CampaignDynamicData, Campaign as CampaignTypeV3 } from "@sdk";
 import type { AprRecord } from "./apr.model";
 export declare abstract class AprService {
     static hashId(opportunityId: string, timestamp: bigint): string;
+    /**
+     * @deprecated
+     */
     static extractFromDynamicData<C extends CampaignTypeV3>(type: C, campaigns: CampaignDynamicData<C>[], timestamp?: bigint): AprRecord["model"];
 }

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

@@ -5,6 +5,9 @@ export class AprService {
     static hashId(opportunityId, timestamp) {
         return Bun.hash(`${opportunityId}${timestamp}`).toString();
     }
+    /**
+     * @deprecated
+     */
     static extractFromDynamicData(type, campaigns, timestamp = BigInt(moment().unix())) {
         const typesWithoutApr = [CampaignTypeV3.INVALID, CampaignTypeV3.JSON_AIRDROP, CampaignTypeV3.ERC20_SNAPSHOT];
         if (typesWithoutApr.includes(type))

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

@@ -160,7 +160,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         authorization: string;
                     };
                     response: {
-                        200: unknown[];
+                        200: unknown[] | undefined;
                     };
                 };
             };

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

@@ -53,7 +53,7 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
         throw new NotFoundError();
     const campaign = await CampaignService.findUniqueOrThrow(id, true);
     const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(Campaign[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
-    return await DynamicDataService.updateForCampaigns([campaignV3]);
+    return await DynamicDataService.update(campaignV3.computeChainId, campaignV3.campaignType, [campaignV3]);
 }, { beforeHandle: BackOfficeGuard, headers: AuthorizationHeadersDto, detail: { hide: true } })
     // ─── Get Many Campaigns ──────────────────────────────────────────────
     .get("/", async ({ query }) => {

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

@@ -280,9 +280,6 @@ export class CampaignService {
     static format(campaign) {
         const { DistributionChain, ComputeChain, Creator, RewardToken, params, CampaignStatus, createdAt, manualOverrides: _, ...c } = campaign;
         const updatedParams = params;
-        if (ComputeChain.name === "Etherlink") {
-            updatedParams.blacklist = [];
-        }
         return {
             ...c,
             params: updatedParams,

package/dist/src/modules/v4/campaign/campaign.test.controller.d.ts

@@ -26,7 +26,7 @@ export declare const CampaignTestController: Elysia<"/campaigns", false, {
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -44,7 +44,7 @@ export declare const CampaignTestController: Elysia<"/campaigns", false, {
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -74,7 +74,7 @@ export declare const CampaignTestController: Elysia<"/campaigns", false, {
                         authorization: string;
                     };
                     response: {
-                        200: unknown[];
+                        200: unknown[] | undefined;
                     };
                 };
             };

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

@@ -1,7 +1,8 @@
 import { NotFoundError } from "@/errors";
+import { InvalidParameter } from "@/errors/InvalidParameter.error";
 import { BackOfficeGuard } from "@/guards/BackOffice.guard";
 import { AuthorizationHeadersDto } from "@/guards/Engine.guard";
-import { Campaign } from "@sdk";
+import { Campaign as CampaignEnum } from "@sdk";
 import Elysia from "elysia";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
 import { OpportunityService } from "../opportunity";
@@ -23,26 +24,29 @@ export const CampaignTestController = new Elysia({
     if (!id)
         throw new NotFoundError();
     const campaign = await CampaignService.findUniqueOrThrow(id, true);
-    const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(Campaign[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
-    return await DynamicDataService.updateForCampaignType([campaignV3], campaignV3.campaignType, true);
+    const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
+    return await DynamicDataService.update(campaignV3.computeChainId, campaignV3.campaignType, [campaignV3], true);
 })
     // ─── Test Dynamic data computation with a list of campaignId ───────────────────────
     .post("/dynamic-data/list", async ({ body }) => {
     const listCampaigns = [];
+    const type = undefined;
     for (const campaignId of body) {
         const id = (await CampaignService.findMany({ campaignId: campaignId, test: true }))?.[0]?.id;
         if (!id)
             throw new NotFoundError();
         const campaign = await CampaignService.findUniqueOrThrow(id, true);
-        const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(Campaign[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
+        const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
         listCampaigns.push(campaignV3);
     }
-    return await DynamicDataService.updateForCampaigns(listCampaigns, true);
+    if (!type)
+        throw new InvalidParameter("No campaign type found");
+    return await DynamicDataService.update(listCampaigns[0].computeChainId, listCampaigns[0].campaignType, listCampaigns, true);
 }, { body: CampaignsDto })
     // ─── Test Dynamic data computation with campaign config ───────────────────────
     .post("/dynamic-data", async ({ body }) => {
-    const listCampaigns = [CampaignService.createFakeCampaign(body)];
-    return await DynamicDataService.updateForCampaigns(listCampaigns, true);
+    const campaign = CampaignService.createFakeCampaign(body);
+    return await DynamicDataService.update(campaign.computeChainId, campaign.campaignType, [campaign], true);
 }, {
     body: CampaignConfigMinimal,
 })
@@ -64,7 +68,7 @@ export const CampaignTestController = new Elysia({
         },
     ]);
     if (!engineCampaigns.length)
-        throw new NotFoundError("Campaign not found in engine db");
+        throw new NotFoundError("CampaignEnum not found in engine db");
     return await OpportunityService.createFromCampaign(engineCampaigns[0], false, false);
 }, {
     query: CampaignUniqueDto,

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

@@ -1,6 +1,14 @@
-import { Campaign, type CampaignDynamicData, type CampaignParameters, type ChainId } from "@sdk";
-import { Campaign as CampaignEnum } from "@sdk";
+import { Campaign as CampaignEnum, type CampaignParameters, type ChainId, type MerklChainId } from "@sdk";
 export declare class DynamicDataService {
+    /**
+     * @notice Updates all records for opportunities associated to the given campaigns
+     *
+     * @dev The list must ONLY contain campaigns of the same type and the same computeChainId
+     */
+    static update(chainId: ChainId, type: CampaignEnum, campaigns: CampaignParameters<CampaignEnum>[], dryRun?: boolean): Promise<unknown[] | undefined>;
+    /**
+     * @dev Test function used to create mock ERC20 static campaigns and check tvl and metadata
+     */
     static queryERC20DynamicData(chainId: ChainId, tokenAddress: string, rewardTokenAddress: string, symbolRewardToken: string, decimals?: number): Promise<{
         tvl: number;
         totalSupply: number;
@@ -9,7 +17,8 @@ export declare class DynamicDataService {
         priceTargetToken: number;
         type: string;
     }>;
-    static getDynamicData(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign, chainId: number): Promise<CampaignDynamicData<CampaignEnum>[]>;
-    static updateForCampaignType(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign, dryRun?: boolean): Promise<unknown[]>;
-    static updateForCampaigns(campaigns: CampaignParameters<CampaignEnum>[], dryRun?: boolean): Promise<unknown[]>;
+    /**
+     * @dev Recursive function to handle errors in fetching dynamic data
+     */
+    static fetchWithRecursiveErrorHandling<R>(fn: (chainId: MerklChainId, campaigns: CampaignParameters<CampaignEnum>[]) => Promise<R[]>, campaigns: CampaignParameters<CampaignEnum>[], chainId: number): Promise<R[]>;
 }