@merkl/api 0.20.43 → 0.20.45

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

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

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

@@ -7,25 +7,15 @@ import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { campaignsToOldFormat } from "@/libs/deprecated-merklv3";
 import { merklChainData } from "@/libs/merklChainData";
 import { staticCampaignWithCache } from "@/libs/staticCampaigns";
-import { InvalidParameter, UnsupportedNetwork } from "@/utils/error";
+import { ChainService } from "@/modules/v4/chain/chain.service";
 import { log } from "@/utils/logger";
 import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "@/utils/queries/allCampaigns";
 import { engineDbClient } from "@db";
-import { Campaign, ChainId, NETWORK_LABELS, isSupportedChain, } from "@sdk";
+import { Campaign, ChainId, NETWORK_LABELS, } from "@sdk";
 import moment from "moment";
 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 () => {
-    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");
-    }
+export const main = async (chainId) => {
     let success = true;
     try {
         await Redis.safeSet(`MerklChainData_${chainId}`, await merklChainData(chainId));
@@ -135,7 +125,11 @@ export const main = async () => {
     }
     return { success };
 };
-main()
+const chains = await ChainService.getSupportedIds();
+const promises = [];
+for (const chain of chains)
+    promises.push(main(chain));
+await Promise.allSettled(promises)
     .then(success => (success ? process.exit(0) : process.exit(1)))
     .catch((err) => {
     console.error(err);

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

@@ -1,14 +1,14 @@
 import { CampaignService } from "@/modules/v4/campaign";
+import { ChainService } from "@/modules/v4/chain/chain.service";
 import { DynamicDataService } from "@/modules/v4/dynamicData/dynamicData.service";
 import { OpportunityService } from "@/modules/v4/opportunity";
 import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
 // ─── Required Env Variables ──────────────────────────────────────────────────
-const chainId = Number(process.env.CHAIN_ID);
-if (!chainId)
-    throw new Error("Environment variable CHAIN_ID is required.");
+// const chainId = Number(process.env.CHAIN_ID);
+// if (!chainId) throw new Error("Environment variable CHAIN_ID is required.");
 // ─── Update Dynamic Data (APR / TVL / Daily Rewards) ─────────────────────────
-const main = async () => {
+const main = async (chainId) => {
     const liveCampaigns = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => {
         return {
             amount: c.amount,
@@ -58,11 +58,13 @@ const main = async () => {
     // 4. Update the status of the opportunities associated to live campaigns
     await OpportunityService.updateMany(liveOpportunityIds, { status: "LIVE" });
 };
-try {
-    await main();
-    process.exit(0);
-}
-catch (err) {
+const chains = await ChainService.getSupportedIds();
+const promises = [];
+for (const chain of chains)
+    promises.push(main(chain));
+await Promise.allSettled(promises)
+    .then(success => (success ? process.exit(0) : process.exit(1)))
+    .catch((err) => {
     console.error(err);
     process.exit(1);
-}
+});

package/dist/src/jobs/update-rpc-calls-cache.js

@@ -3,14 +3,13 @@ import { TTLPresets } from "@/modules/v4/cache/cache.model";
 import { ChainService } from "@/modules/v4/chain/chain.service";
 import { MerklRootRepository } from "@/modules/v4/merklRoot/merklRoot.repository";
 import { OpportunityService } from "@/modules/v4/opportunity";
-import { NETWORK_LABELS, log, withTimeout } from "@sdk";
+import { NETWORK_LABELS, log } from "@sdk";
 const main = async () => {
     try {
         const chains = await ChainService.getSupportedIds();
         const promises = [];
         for (const chain of chains)
-            promises.push(withTimeout(CacheService.set(TTLPresets.MIN_30, MerklRootRepository.fetch, chain).catch(_err => log.warn(`RPC calls cache update failed for ${NETWORK_LABELS[chain]}.`)), 60_000 // There is no reason for this call to take more than 60 sec
-            ));
+            promises.push(MerklRootRepository.fetch(chain).catch(_err => log.warn(`RPC calls cache update failed for ${NETWORK_LABELS[chain]}.`)));
         await Promise.allSettled(promises);
         // ─── Refresh Cache For GET /opportunities ────
         await CacheService.set(TTLPresets.MIN_5, OpportunityService.findMany, { items: 25, page: 0 });

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

@@ -1,4 +1,4 @@
-import { type ChainId } from "@sdk";
+import { type ChainId, DistributorService } from "@sdk";
 import type { CreateRootModel, RootByTimestampModel } from "./merklRoot.model";
 export declare class MerklRootRepository {
     static firstRoot(chainId: ChainId): Promise<{
@@ -13,13 +13,7 @@ export declare class MerklRootRepository {
         root: string;
         epoch: number;
     }[]>;
-    static fetch(chainId: ChainId): Promise<{
-        live: any;
-        tree: any;
-        lastTree: any;
-        endOfDisputePeriod: any;
-        disputer: any;
-    }>;
+    static fetch(chainId: ChainId): Promise<Partial<Awaited<ReturnType<ReturnType<typeof DistributorService>["fetchUpdateData"]>>>>;
     static create(x: CreateRootModel): Promise<{
         chainId: number;
         timestamp: bigint;

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

@@ -1,5 +1,6 @@
+import { log } from "@/utils/logger";
 import { apiDbClient } from "@db";
-import { DistributorService } from "@sdk";
+import { DistributorService, NETWORK_LABELS, withTimeout } from "@sdk";
 export class MerklRootRepository {
     static async firstRoot(chainId) {
         return await apiDbClient.merklRoot.findFirst({
@@ -24,8 +25,21 @@ export class MerklRootRepository {
         return [res[0], res[1]];
     }
     static async fetch(chainId) {
-        const { live, tree, lastTree, endOfDisputePeriod, disputer } = await DistributorService(chainId).fetchUpdateData();
-        return { live, tree, lastTree, endOfDisputePeriod, disputer };
+        const RPC_CALL_TIMEOUT = 4_000;
+        try {
+            // Try fetching the data using a RPC
+            const { live, tree, lastTree, endOfDisputePeriod, disputer } = await withTimeout(DistributorService(chainId).fetchUpdateData(), RPC_CALL_TIMEOUT);
+            return { live, tree, lastTree, endOfDisputePeriod, disputer };
+        }
+        catch (e) {
+            // If the error is a timeout, log a warning and return a void object
+            if (e.message === `Timed out after ${RPC_CALL_TIMEOUT}ms`) {
+                const errorMessage = `fetching Merkle Root for chain ${NETWORK_LABELS[chainId]} timed out`;
+                log.warn(errorMessage);
+                return {};
+            }
+            throw e;
+        }
     }
     static async create(x) {
         return await apiDbClient.merklRoot.create({

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

@@ -13,19 +13,7 @@ export declare class MerklRootService {
         root: string;
         epoch: number;
     }[]>;
-    /**
-     * Fetch roots for the provided chain
-     * @param chainId to fetch roots for
-     * @returns object with live and last tree roots
-     */
-    static fetch(chainId: ChainId): Promise<any>;
-    static fetchFromCache(chainId: ChainId): Promise<{
-        live: any;
-        tree: any;
-        lastTree: any;
-        endOfDisputePeriod: any;
-        disputer: any;
-    }>;
+    static fetchFromCache(chainId: ChainId): Promise<any>;
     /**
      * Fetch all roots for the provided chains
      * @param chainIds to fetch roots for

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

@@ -1,6 +1,5 @@
-import { HttpError } from "@/errors";
 import { log } from "@/utils/logger";
-import { NETWORK_LABELS, withTimeout } from "@sdk";
+import { NETWORK_LABELS } from "@sdk";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
 import { ChainService } from "../chain/chain.service";
@@ -12,36 +11,16 @@ export class MerklRootService {
     static async rootForTimestamp(x) {
         return await MerklRootRepository.rootForTimestamp(x);
     }
-    /**
-     * Fetch roots for the provided chain
-     * @param chainId to fetch roots for
-     * @returns object with live and last tree roots
-     */
-    static async fetch(chainId) {
-        try {
-            return await withTimeout(CacheService.wrap(TTLPresets.MIN_1, MerklRootRepository.fetch, chainId), 5_000);
-        }
-        catch (e) {
-            if (e.message === "Timed out after 3000ms") {
-                const errorMessage = `fetching Merkle Root for chain ${NETWORK_LABELS[chainId]} timed out`;
-                log.warn(errorMessage);
-                throw new Error(errorMessage);
-            }
-            throw e;
-        }
-    }
     static async fetchFromCache(chainId) {
-        try {
-            const data = await CacheService.get(MerklRootRepository.fetch, [chainId]);
-            if (data === null)
-                throw new Error("DATA_NOT_FOUND");
-            return data;
-        }
-        catch (err) {
-            if (err && err instanceof Error && err.message === "DATA_NOT_FOUND")
-                throw new HttpError(`Failed to fetch data for chain ${NETWORK_LABELS[chainId]}.`, 500);
-            return await MerklRootRepository.fetch(chainId);
+        let data = await CacheService.get(MerklRootRepository.fetch, [chainId]);
+        // If the data is null, it means the cache is empty
+        if (data === null) {
+            log.info(`cache is empty for Merkle Root on ${NETWORK_LABELS[chainId]}, using rpc...`);
+            data = await CacheService.wrap(TTLPresets.MIN_1, MerklRootRepository.fetch, chainId);
         }
+        if (data.lastTree === undefined)
+            throw `fetching Merkle Root on ${NETWORK_LABELS[chainId]} timed out`;
+        return data;
     }
     /**
      * Fetch all roots for the provided chains