@merkl/api 0.20.8 → 0.20.10

package/package.json

@@ -107,5 +107,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "v0.20.8"
+  "version": "v0.20.10"
 }

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

@@ -1,53 +0,0 @@
-import { Campaign, type CampaignDynamicData, ChainId } from "@sdk";
-import { Elysia } from "elysia";
-/**
- * @deprecated Used only for the v3/campaigns route
- */
-export type CampaignsCacheUpdaterReturnType = {
-    [type_mainParameter: string]: {
-        [campaignId: string]: CampaignDynamicData<Campaign>;
-    };
-};
-export declare const campaignsCacheUpdater: Elysia<"", false, {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    type: {};
-    error: {};
-}, {
-    schema: {};
-    macro: {};
-    macroFn: {};
-}, {
-    v3: {
-        update: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {
-                    campaignTypes?: number[] | undefined;
-                    chainId: string;
-                };
-                headers: unknown;
-                response: {
-                    200: {
-                        success: boolean;
-                    };
-                };
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;
-export declare const campaignCacheUpdate: (rawChainId: string, queryCampaignTypes: number[], highCampaignsChains: ChainId[]) => Promise<{
-    success: boolean;
-}>;

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

@@ -1,173 +0,0 @@
-import { Redis } from "@/cache";
-import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
-import { campaignsToOldFormat } from "@/libs/deprecated-merklv3";
-import { AprService } from "@/modules/v4/apr";
-import { CacheService } from "@/modules/v4/cache";
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CampaignService } from "@/modules/v4/campaign";
-import { OpportunityService } from "@/modules/v4/opportunity";
-import { OpportunityRepository } from "@/modules/v4/opportunity/opportunity.repository";
-import { RewardService } from "@/modules/v4/reward";
-import { TvlService } from "@/modules/v4/tvl";
-import { engineDbClient } from "@db";
-import { Campaign, ChainId, NETWORK_LABELS, isSupportedChain, } from "@sdk";
-import { Elysia, t } from "elysia";
-import moment from "moment";
-import { merklChainData } from "../../libs/merklChainData";
-import { staticCampaignWithCache } from "../../libs/staticCampaigns";
-import { InvalidParameter, UnsupportedNetwork } from "../../utils/error";
-import { log } from "../../utils/logger";
-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);
-        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
-            const campaignTypes = !!queryCampaignTypes?.length
-                ? queryCampaignTypes
-                : !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 dynamicDataBuilderFactory(campaignType)
-                    .build(chainId, campaigns)
-                    .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)) {
-                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("_");
-                try {
-                    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);
-                }
-                catch { }
-            }
-            await OpportunityService.updateMetadata(chainId);
-            // ─── Refresh Cache For GET /opportunities ────
-            await CacheService.set(TTLPresets.MIN_5, OpportunityService.findMany, { 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 };
-};