@merkl/api 0.14.3 → 0.14.5

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

@@ -0,0 +1,9 @@
+import { Campaign, type CampaignDynamicData } from "@sdk";
+export type CampaignsCacheUpdaterReturnType = {
+    [type_mainParameter: string]: {
+        [campaignId: string]: CampaignDynamicData<Campaign>;
+    };
+};
+export declare const main: () => Promise<{
+    success: boolean;
+}>;

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

@@ -0,0 +1,165 @@
+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 { 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 highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
+export const main = async () => {
+    const rawChainId = process.env.CHAIN_ID;
+    let chainId;
+    if (typeof rawChainId === "string") {
+        chainId = Number.parseInt(rawChainId);
+        if (!isSupportedChain(chainId, "merkl"))
+            throw new UnsupportedNetwork(chainId);
+    }
+    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 };
+};
+main()
+    .then(success => (success ? process.exit(0) : process.exit(1)))
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/jobs/etl/reward-breakdowns.js

@@ -1,6 +1,7 @@
 // ─── Reward Breakdowns ETL ───────────────────────────────────────────────────
 if (!process.env.ENV || !process.env.CHAIN_ID || !process.env.ROOT)
     throw new Error("[ENV]: missing variable");
+import { CampaignService } from "../../modules/v4";
 import { log } from "../../utils/logger";
 import { apiDbClient } from "../../utils/prisma";
 import { withRetry } from "@sdk";
@@ -32,7 +33,7 @@ const extract = async () => {
         buffer = lines.pop() || "";
         for (const line of lines)
             if (line.trim()) {
-                data.push(...transform(JSON.parse(line)));
+                data.push(...(await transform(JSON.parse(line))));
             }
         try {
             count += await withRetry(load, [data], 5, 60_000);
@@ -47,7 +48,33 @@ const extract = async () => {
     return count;
 };
 // ─── Transform ───────────────────────────────────────────────────────────────
-const transform = (rewardBreakdowns) => {
+const transform = async (rewardBreakdowns) => {
+    const missingCampaigns = [];
+    const foundCampaigns = [];
+    const campaigns = rewardBreakdowns.reduce((acc, x) => {
+        const campaignUnique = {
+            campaignId: x.campaignId,
+            distributionChain: Number.parseInt(process.env.CHAIN_ID),
+        };
+        if (!Object.keys(acc).includes(CampaignService.hashId(campaignUnique)))
+            acc[CampaignService.hashId(campaignUnique)] = {
+                campaignId: x.campaignId,
+                distributionChain: Number.parseInt(process.env.CHAIN_ID),
+            };
+        return acc;
+    }, {});
+    for (const campaign of Object.values(campaigns)) {
+        const campaignExists = await CampaignService.checkIfExist(campaign);
+        if (!campaignExists) {
+            const { success, fail } = await CampaignService.fill([campaign]);
+            if (fail === 1 || success !== 1) {
+                missingCampaigns.push(CampaignService.hashId(campaign));
+                log.warn(`createManyBreakdown - Missing campaign: ${campaign.campaignId}`);
+                continue;
+            }
+        }
+        foundCampaigns.push(CampaignService.hashId(campaign));
+    }
     const transformedRewardBreakdowns = [];
     for (const rewardBreakdown of rewardBreakdowns) {
         const campaignId = Bun.hash(`${process.env.CHAIN_ID}${rewardBreakdown.campaignId}`).toString();
@@ -63,7 +90,7 @@ const transform = (rewardBreakdowns) => {
             pending: rewardBreakdown.pending,
         });
     }
-    return transformedRewardBreakdowns;
+    return transformedRewardBreakdowns.filter(x => !missingCampaigns.includes(x.campaignId));
 };
 // ─── Load ────────────────────────────────────────────────────────────────────
 const load = async (rewardBreakdowns) => {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/EulerBorrowProcessor.js

@@ -21,8 +21,8 @@ export class EulerBorrowProcessor extends GenericProcessor {
         const decimalsAsset = Number(campaign.campaignParameters.decimalsAsset);
         const priceAsset = (await pricer.get({ symbol: symbolAsset })) ?? 1;
         const totalBorrows = BN2Number(typeInfo.totalAssets, decimalsAsset);
-        let cardName = generateCardName(type, typeInfo, campaign);
         typeInfo.symbolUnderlyingToken = symbolAsset;
+        let cardName = generateCardName(type, typeInfo, campaign);
         const vaultName = await fetchEulerVaultName(campaign.campaignParameters.evkAddress, campaign.chainId);
         if (!!vaultName) {
             cardName = `Borrow from ${vaultName} vault`;