@merkl/api 0.15.48 → 0.16.0

package/dist/src/backgroundJobs/jobs/campaignsCacheUpdater.d.ts

@@ -1,4 +1,4 @@
-import { Campaign, type CampaignDynamicData } from "@sdk";
+import { Campaign, type CampaignDynamicData, ChainId } from "@sdk";
 import { Elysia } from "elysia";
 export type CampaignsCacheUpdaterReturnType = {
     [type_mainParameter: string]: {
@@ -45,3 +45,6 @@ export declare const campaignsCacheUpdater: Elysia<"", false, {
     resolve: {};
     schema: {};
 }>;
+export declare const campaignCacheUpdate: (rawChainId: string, queryCampaignTypes: number[], highCampaignsChains: ChainId[]) => Promise<{
+    success: boolean;
+}>;

package/dist/src/backgroundJobs/jobs/campaignsCacheUpdater.js

@@ -20,6 +20,15 @@ import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "../../utils/queries/allCampaigns"
 const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
 export const campaignsCacheUpdater = new Elysia().get("/v3/update", async ({ query }) => {
     const rawChainId = query.chainId;
+    const queryCampaignTypes = query?.campaignTypes ? query.campaignTypes : [];
+    return campaignCacheUpdate(rawChainId, queryCampaignTypes, highCampaignsChains);
+}, {
+    query: t.Object({
+        chainId: t.String(),
+        campaignTypes: t.Optional(t.Array(t.Numeric())),
+    }),
+});
+export const campaignCacheUpdate = async (rawChainId, queryCampaignTypes, highCampaignsChains) => {
     let chainId;
     if (typeof rawChainId === "string") {
         chainId = Number.parseInt(rawChainId);
@@ -58,8 +67,8 @@ export const campaignsCacheUpdater = new Elysia().get("/v3/update", async ({ que
         log.local(`Data length after filtering: ${staticData.length}`);
         if (!!staticData) {
             // Build list of existing campaign types for this chain
-            const campaignTypes = !!query?.campaignTypes?.length
-                ? query.campaignTypes
+            const campaignTypes = !!queryCampaignTypes?.length
+                ? queryCampaignTypes
                 : !staticData
                     ? []
                     : staticData
@@ -160,9 +169,4 @@ export const campaignsCacheUpdater = new Elysia().get("/v3/update", async ({ que
         log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
     }
     return { success };
-}, {
-    query: t.Object({
-        chainId: t.String(),
-        campaignTypes: t.Optional(t.Array(t.Numeric())),
-    }),
-});
+};

package/dist/src/jobs/etl/dynamic-data.d.ts

@@ -1,4 +1,4 @@
-import { Campaign, type CampaignDynamicData } from "@sdk";
+import { type Campaign, type CampaignDynamicData } from "@sdk";
 export type CampaignsCacheUpdaterReturnType = {
     [type_mainParameter: string]: {
         [campaignId: string]: CampaignDynamicData<Campaign>;

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

@@ -1,22 +1,7 @@
-import { Redis } from "../../cache";
-import { campaignsToOldFormat } from "../../libs/deprecated-merklv3";
-import { AprService, CampaignService, OpportunityService } from "../../modules/v4";
-import { CacheService } from "../../modules/v4/cache";
-import { TTLPresets } from "../../modules/v4/cache/cache.model";
-import { OpportunityRepository } from "../../modules/v4/opportunity/opportunity.repository";
-import { RewardService } from "../../modules/v4/reward";
-import { TvlService } from "../../modules/v4/tvl";
-import { engineDbClient } from "../../utils/prisma";
-import { Campaign, ChainId, NETWORK_LABELS, isSupportedChain, } from "@sdk";
-import moment from "moment";
-import { campaignsDynamicData } from "../../libs/campaigns/campaignsDynamicData";
-import { merklChainData } from "../../libs/merklChainData";
-import { staticCampaignWithCache } from "../../libs/staticCampaigns";
+import { campaignCacheUpdate } from "../../backgroundJobs/jobs/campaignsCacheUpdater";
+import { ChainId, isSupportedChain } from "@sdk";
 import { InvalidParameter, UnsupportedNetwork } from "../../utils/error";
-import { executeSimple } from "../../utils/execute";
-import { log } from "../../utils/logger";
-import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "../../utils/queries/allCampaigns";
-let campaignTypes = process.env.CAMPAIGN_TYPES ? JSON.parse(process.env.CAMPAIGN_TYPES) : [];
+const campaignTypes = process.env.CAMPAIGN_TYPES ? JSON.parse(process.env.CAMPAIGN_TYPES) : [];
 const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
 export const main = async () => {
     const rawChainId = process.env.CHAIN_ID;
@@ -29,133 +14,7 @@ export const main = async () => {
     else {
         throw new InvalidParameter("Invalid chainId provided");
     }
-    let success = true;
-    try {
-        await Redis.safeSet(`MerklChainData_${chainId}`, await merklChainData(chainId));
-    }
-    catch (error) {
-        log.error(`❌ update merklChainData cache failed for ${NETWORK_LABELS[chainId]}`, error);
-        success = false;
-    }
-    log.local(`🔁 updating ${NETWORK_LABELS[chainId]} Campaigns cache`);
-    let campaignsAfter = moment().subtract(3, "months").unix();
-    if (highCampaignsChains.includes(chainId)) {
-        campaignsAfter = moment().subtract(1, "months").unix();
-    }
-    const TWO_WEEKS_AGO = moment().subtract(2, "weeks").unix();
-    try {
-        const dynamicData = {};
-        let staticData = (await engineDbClient.$queryRaw(ALL_CAMPAIGNS_FOR_CHAIN_AFTER(chainId, campaignsAfter)));
-        log.local(`Data length before filtering: ${staticData.length}`);
-        const mainParameters = {};
-        staticData = staticData.filter(campaign => {
-            if (campaign.endTimestamp < TWO_WEEKS_AGO && campaign.campaignType === Campaign.CLAMM) {
-                campaign.campaignParameters.forwarders = [];
-            }
-            mainParameters[campaign.mainParameter] = true;
-            return true;
-        });
-        log.local(`Data length after filtering: ${staticData.length}`);
-        if (!!staticData) {
-            // Build list of existing campaign types for this chain
-            campaignTypes = !!campaignTypes.length
-                ? campaignTypes
-                : !staticData
-                    ? []
-                    : staticData
-                        .map(campaign => campaign.campaignType)
-                        .reduce((prev, campaignType) => {
-                        if (!prev.includes(campaignType))
-                            prev.push(campaignType);
-                        return prev;
-                    }, []);
-            // Fetch dynamic data for all these types
-            const promisesPerType = campaignTypes.map(async (campaignType) => {
-                const campaigns = staticData.filter(campaign => campaign.campaignType === campaignType);
-                await executeSimple(chainId, campaignsDynamicData(chainId, campaigns, campaignType)).then(r => {
-                    for (const d of r) {
-                        if (!!d) {
-                            // Main Parameter OVERRIDING
-                            if (d.campaignType === Campaign.SILO && d.campaignParameters.whitelist?.length === 1) {
-                                d.mainParameter = `${d.mainParameter}-${d.campaignParameters.whitelist[0]}`;
-                            }
-                            if (!dynamicData[`${d.campaignType}_${d.mainParameter}`])
-                                dynamicData[`${d.campaignType}_${d.mainParameter}`] = {};
-                            dynamicData[`${d.campaignType}_${d.mainParameter}`][d.campaignId] = d;
-                        }
-                    }
-                });
-            });
-            await Promise.all(promisesPerType);
-        }
-        if (!!dynamicData && Object.keys(dynamicData).length > 0) {
-            await Redis.safeSet(`Campaigns_${chainId}`, dynamicData);
-            // Set live or future campaigns
-            const liveDynamicData = {};
-            for (const [type_mainParameter, value] of Object.entries(dynamicData)) {
-                const liveDynamicData = {};
-                for (const [campaignId, data] of Object.entries(value)) {
-                    if (data.endTimestamp > moment().unix()) {
-                        if (!liveDynamicData[type_mainParameter]) {
-                            liveDynamicData[type_mainParameter] = {};
-                        }
-                        liveDynamicData[type_mainParameter][campaignId] = data;
-                    }
-                }
-            }
-            await Redis.safeSet(`LiveCampaigns_${chainId}`, liveDynamicData);
-            const merklChainData = await Redis.get("MerklChainData", chainId);
-            await Redis.safeSet(`CampaignsOldFormat_${chainId}`, campaignsToOldFormat(dynamicData, merklChainData));
-            await Redis.safeSet(`LiveCampaignsOldFormat_${chainId}`, campaignsToOldFormat(liveDynamicData, merklChainData));
-            log.info(`✅ ${NETWORK_LABELS[chainId]} caches updated successfully`);
-            for (const entry of Object.entries(liveDynamicData)) {
-                await CampaignService.fill(Object.values(entry[1]).map(({ campaignId, chainId }) => ({
-                    campaignId,
-                    distributionChain: chainId,
-                })));
-                const [type, mainParameter] = entry[0].split("_");
-                const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
-                const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
-                const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
-                const opportunityId = OpportunityService.hashId({
-                    chainId,
-                    identifier: mainParameter,
-                    type: CampaignService.getTypeFromV3(+type),
-                });
-                await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
-            }
-            await OpportunityService.updateMetadata(chainId);
-            // ─── Refresh Cache For GET /opportunities ────
-            await CacheService.set(TTLPresets.MIN_5, OpportunityService.getMany, { items: 50, page: 0 });
-            log.info(`✅ ${NETWORK_LABELS[chainId]} DB records updated successfully`);
-        }
-        else {
-            if (chainId === ChainId.CORE || chainId === ChainId.THUNDERCORE) {
-                log.info(`⚠️ no campaigns found for ${NETWORK_LABELS[chainId]}, setting empty cache`);
-                for (const key of [
-                    "Campaigns",
-                    "LiveCampaigns",
-                    "CampaignsOldFormat",
-                    "LiveCampaignsOldFormat",
-                ]) {
-                    await Redis.safeSet(`${key}_${chainId}`, {});
-                }
-                log.info(`✅ ${NETWORK_LABELS[chainId]} caches updated - empty cache`);
-            }
-        }
-    }
-    catch (error) {
-        log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
-        success = false;
-    }
-    // This is independant of campaigns cache update, so not in the if condition
-    try {
-        await staticCampaignWithCache(chainId);
-    }
-    catch (error) {
-        log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
-    }
-    return { success };
+    return campaignCacheUpdate(rawChainId, campaignTypes, highCampaignsChains);
 };
 main()
     .then(success => (success ? process.exit(0) : process.exit(1)))

package/dist/src/jobs/etl/pendings.js

@@ -148,7 +148,8 @@ const updatePendings = async (data) => {
         }
     }
     const totalRewardIncrease = Object.values(rewardIdToPendingIncrease).reduce((prev, current) => prev + BigInt(current.pendingIncrease), 0n);
-    log.info(`rewards to create: ${rewardToCreate.length}, to update: ${rewardToUpdate.length}, total reward increase: ${totalRewardIncrease.toString()}`);
+    log.info(`total increase: ${totalRewardIncrease.toString()}, rewards to create:    ${rewardToCreate.length}, to update: ${rewardToUpdate.length}`);
+    log.info(`total increase: ${totalBreakdownIncrease.toString()}, breakdowns to create: ${breakdownToCreate.length}, to update: ${breakdownToUpdate.length}`);
     if (rewardToCreate.length > 0) {
         const users = rewardToCreate.map(x => x.recipient);
         await apiDbClient.user.createMany({ data: users.map(x => ({ address: x, tags: [] })), skipDuplicates: true });
@@ -168,20 +169,21 @@ const updatePendings = async (data) => {
             }),
         });
     }
-    if (rewardToUpdate.length > 0) {
-        await apiDbClient.$transaction(rewardToUpdate.map(x => {
-            const rewardId = Bun.hash(`${data.root}${x.recipient}${rewardTokenId}`).toString();
-            return apiDbClient.reward.update({
-                where: {
-                    id: rewardId,
-                },
-                data: {
-                    pending: x.pending.toString(),
-                },
-            });
-        }));
+    if (breakdownToCreate.length > 0) {
+        await apiDbClient.rewardBreakdown.createMany({
+            data: breakdownToCreate.map(x => {
+                const rewardId = Bun.hash(`${root}${x.recipient}${rewardTokenId}`).toString();
+                return {
+                    reason: x.reason,
+                    amount: "0",
+                    pending: x.pending,
+                    claimed: "0",
+                    rewardId,
+                    campaignId,
+                };
+            }),
+        });
     }
-    log.info(`breakdowns to create: ${breakdownToCreate.length}, to update: ${breakdownToUpdate.length}, total breakdown increase: ${totalBreakdownIncrease.toString()}`);
     if (breakdownToUpdate.length > 0) {
         await apiDbClient.$transaction(breakdownToUpdate.map(x => {
             return apiDbClient.rewardBreakdown.update({
@@ -198,20 +200,18 @@ const updatePendings = async (data) => {
             });
         }));
     }
-    if (breakdownToCreate.length > 0) {
-        await apiDbClient.rewardBreakdown.createMany({
-            data: breakdownToCreate.map(x => {
-                const rewardId = Bun.hash(`${root}${x.recipient}${rewardTokenId}`).toString();
-                return {
-                    reason: x.reason,
-                    amount: "0",
-                    pending: x.pending,
-                    claimed: "0",
-                    rewardId,
-                    campaignId,
-                };
-            }),
-        });
+    if (rewardToUpdate.length > 0) {
+        await apiDbClient.$transaction(rewardToUpdate.map(x => {
+            const rewardId = Bun.hash(`${data.root}${x.recipient}${rewardTokenId}`).toString();
+            return apiDbClient.reward.update({
+                where: {
+                    id: rewardId,
+                },
+                data: {
+                    pending: x.pending.toString(),
+                },
+            });
+        }));
     }
     return { created: breakdownToCreate.length, updated: breakdownToUpdate.length };
 };