@merkl/api 0.17.7 → 0.17.8

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

@@ -6,7 +6,8 @@ import { OpportunityRepository } from "../../modules/v4/opportunity/opportunity.
 import { RewardService } from "../../modules/v4/reward";
 import { TvlService } from "../../modules/v4/tvl";
 import { executeSimple } from "../../utils/execute";
-import { Campaign as CampaignTypesEnum } from "@sdk";
+import { log } from "../../utils/logger";
+import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
 // ─── Required Env Variables ──────────────────────────────────────────────────
 const chainId = Number(process.env.CHAIN_ID);
@@ -31,7 +32,7 @@ async function updateDynamicData(liveCampaigns, campaignType) {
     for (const data of dynamicData) {
         if (!!data) {
             // Main Parameter OVERRIDING
-            if (data.campaignType === CampaignTypesEnum.SILO && data.campaignParameters.whitelist?.length === 1)
+            if (data.campaignType === CampaignEnum.SILO && data.campaignParameters.whitelist?.length === 1)
                 data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
             if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
                 oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
@@ -57,25 +58,9 @@ async function updateDynamicData(liveCampaigns, campaignType) {
     }
 }
 // ─── Get And Transform Live Campaigns Into A Map ─────────────────────────────
-const getLiveCampaignsByType = async (chainId) => {
-    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: c.type,
-            chainId: c.distributionChainId,
-            computeChainId: c.computeChainId,
-            creator: c.creatorAddress,
-            endTimestamp: c.endTimestamp,
-            rewardToken: c.rewardTokenId,
-            startTimestamp: c.startTimestamp,
-        };
-    });
+const buildMapByType = async (campaignsToUpdate) => {
     const campaignTypeToCampaigns = new Map();
-    for (const campaign of liveCampaigns) {
+    for (const campaign of campaignsToUpdate) {
         const type = campaign.campaignType;
         let campaigns = campaignTypeToCampaigns.get(campaign.campaignType);
         if (!campaigns)
@@ -87,22 +72,43 @@ const getLiveCampaignsByType = async (chainId) => {
     return campaignTypeToCampaigns;
 };
 // ─── Main function / entry point ─────────────────────────────────────────────
-const main = async () => {
+const updateCampaigns = async (campaignsToUpdate) => {
     // 1. Get a map of campaigns by campaign type
-    const liveCampaigns = await getLiveCampaignsByType(chainId);
+    const campaignTypeToCampaigns = await buildMapByType(campaignsToUpdate);
     // 2. Call updateDynamicData with each entries of the map (process by campaign type)
-    for (const [type, campaigns] of liveCampaigns.entries()) {
+    for (const [campaignType, campaigns] of campaignTypeToCampaigns.entries()) {
+        log.info(`updating dynamic data for ${campaigns.length} campaigns of type ${CampaignEnum[campaignType]}`);
         try {
-            await updateDynamicData(campaigns, type);
+            await updateDynamicData(campaigns, campaignType);
         }
         catch (err) {
-            console.error(`Failed to update dynamic data for campaign type ${type}`, err);
+            console.error(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, err);
         }
     }
-    // 3. Update status of opportunities
-    // 3.1 Get current live opportunities
+};
+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.rewardTokenId,
+            startTimestamp: Number(c.startTimestamp),
+            index: 0,
+        };
+    });
+    await updateCampaigns(liveCampaigns);
+    // Update status of opportunities
+    // 1. Get current live opportunities
     const liveOpportunities = await OpportunityService.findLiveWithCampaigns(chainId);
-    // 3.2 For each currently live opportunities, infer its updated status by looping through its campaigns
+    // 2. For each currently live opportunities, infer its updated status by looping through its campaigns
     const now = moment().unix();
     for (const opportunity of liveOpportunities) {
         let status = "NONE";
@@ -117,16 +123,12 @@ const main = async () => {
         }
         await OpportunityService.updateStatus(opportunity.id, status);
     }
-    // 4. Compute opportunity ids of liveCampaigns
-    const opportunities = new Set();
-    for (const [type, campaigns] of liveCampaigns.entries()) {
-        for (const campaign of campaigns) {
-            const opportunityId = OpportunityService.hashId({ chainId, identifier: campaign.mainParameter, type });
-            opportunities.add(opportunityId);
-        }
-    }
-    // 5. Update the status of the liveCampaigns opportunities
-    await OpportunityService.updateMany(Array.from(opportunities), { status: "LIVE" });
+    // 3. Update the status of the opportunities associated to future campaigns
+    const futureOpportunityIds = (await CampaignService.getFutureCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    await OpportunityService.updateMany(futureOpportunityIds, { status: "SOON" });
+    // 4. Update the status of the opportunities associated to live campaigns
+    const liveOpportunityIds = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    await OpportunityService.updateMany(liveOpportunityIds, { status: "LIVE" });
 };
 try {
     await main();

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

@@ -71,8 +71,29 @@ export declare abstract class CampaignRepository {
      * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
      *
      * @returns A promise that resolves to an array of past campaigns.
+     *
+     * @dev Excludes test campaigns
      */
-    static getPastCampaigns(chainId?: number): Promise<{
+    static getPastCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
         type: string;
         id: string;
         params: Prisma.JsonValue;
@@ -86,12 +107,56 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    }[]>;
+    })[]>;
+    /**
+     * Retrieves all past campaigns from the database.
+     * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
+     *
+     * @returns A promise that resolves to an array of past campaigns.
+     *
+     * @dev Excludes test campaigns
+     */
+    static getFutureCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
+        type: string;
+        id: string;
+        params: Prisma.JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    })[]>;
     /**
      * Retrieves all live campaigns from the database.
      * A campaign is considered live if the current timestamp is between the campaign's start and end timestamps.
      *
      * @returns A promise that resolves to an array of live campaigns.
+     *
+     * @dev Excludes test campaigns
      */
     static getLiveCampaigns(query?: {
         computeChainId?: number;

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

@@ -54,15 +54,50 @@ export class CampaignRepository {
      * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
      *
      * @returns A promise that resolves to an array of past campaigns.
+     *
+     * @dev Excludes test campaigns
      */
-    static async getPastCampaigns(chainId) {
+    static async getPastCampaigns(query) {
         const now = moment().unix();
+        const where = {
+            ...query,
+            endTimestamp: {
+                lt: now,
+            },
+            RewardToken: {
+                isTest: false,
+            },
+        };
         return await apiDbClient.campaign.findMany({
-            where: {
-                computeChainId: chainId,
-                endTimestamp: {
-                    lt: now,
-                },
+            where,
+            include: {
+                Opportunity: true,
+            },
+        });
+    }
+    /**
+     * Retrieves all past campaigns from the database.
+     * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
+     *
+     * @returns A promise that resolves to an array of past campaigns.
+     *
+     * @dev Excludes test campaigns
+     */
+    static async getFutureCampaigns(query) {
+        const now = moment().unix();
+        const where = {
+            ...query,
+            startTimestamp: {
+                gt: now,
+            },
+            RewardToken: {
+                isTest: false,
+            },
+        };
+        return await apiDbClient.campaign.findMany({
+            where,
+            include: {
+                Opportunity: true,
             },
         });
     }
@@ -71,6 +106,8 @@ export class CampaignRepository {
      * A campaign is considered live if the current timestamp is between the campaign's start and end timestamps.
      *
      * @returns A promise that resolves to an array of live campaigns.
+     *
+     * @dev Excludes test campaigns
      */
     static async getLiveCampaigns(query) {
         const now = moment().unix();
@@ -78,6 +115,9 @@ export class CampaignRepository {
             ...query,
             endTimestamp: { gte: now },
             startTimestamp: { lte: now },
+            RewardToken: {
+                isTest: false,
+            },
         };
         return await apiDbClient.campaign.findMany({
             where,

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

@@ -4,7 +4,26 @@ import { CampaignRepository } from "./campaign.repository";
 export declare abstract class CampaignService {
     static hashId(campaign: CampaignUnique): string;
     static splitIdOrThrow(chainAndCampaignId: `${number}-${string}` | string): CampaignUnique;
-    static getPastCampaigns(chainId?: number): Promise<{
+    static getPastCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
         type: string;
         id: string;
         params: import("database/api/.generated/runtime/library").JsonValue;
@@ -18,7 +37,41 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    }[]>;
+    })[]>;
+    static getFutureCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
+        type: string;
+        id: string;
+        params: import("database/api/.generated/runtime/library").JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    })[]>;
     static getLiveCampaigns(query?: {
         computeChainId?: number;
         type?: string;

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

@@ -21,8 +21,11 @@ export class CampaignService {
         const [chainId, campaignId] = chainAndCampaignId.split("-");
         return { distributionChain: +chainId, campaignId };
     }
-    static async getPastCampaigns(chainId) {
-        return await CampaignRepository.getPastCampaigns(chainId);
+    static async getPastCampaigns(query) {
+        return await CampaignRepository.getPastCampaigns(query);
+    }
+    static async getFutureCampaigns(query) {
+        return await CampaignRepository.getFutureCampaigns(query);
     }
     static async getLiveCampaigns(query) {
         return await CampaignRepository.getLiveCampaigns(query);