@merkl/api 0.20.18 → 0.20.20

package/dist/src/engine/dynamicData/implementations/EventBased.js

@@ -39,8 +39,6 @@ async function computeEventBasedPoolTVLFromMostRecentStateSave(chainId, campaign
     // Bucket service
     let tvl = 0;
     try {
-        if (bucketName === undefined)
-            console.log("EVENT_BASED:", states);
         const bucket = new BucketService("merkl-production-states", "merkl-production");
         const storedStates = JSON.parse(await bucket.pull(fileName));
         for (const [_, { value, params: _params }] of Object.entries(storedStates)) {

package/dist/src/engine/dynamicData/implementations/UniswapV4.js

@@ -32,19 +32,17 @@ async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, price
         stateSave = mostRecentStateSave.state;
         blockNumber = mostRecentStateSave?.blockNumber;
         states = stateSave.states;
-        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
     }
-    catch (e) {
+    catch {
         log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+        return { tvl: 0, amount0: 0, amount1: 0, blockNumber: blockNumber ?? 0 };
     }
-    const { fileName, bucketName } = states;
+    const { fileName } = states;
     // Bucket service
     let tvl = 0;
     let amount0 = 0;
     let amount1 = 0;
     try {
-        if (bucketName === undefined)
-            console.log("UNIV4", states);
         const bucket = new BucketService("merkl-production-states", "merkl-production");
         const storedStates = JSON.parse(await bucket.pull(fileName));
         for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
@@ -53,8 +51,7 @@ async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID, price
         }
         tvl = amount0 * (priceCurrency0 ?? 0) + amount1 * (priceCurrency1 ?? 0);
     }
-    catch (e) {
-        console.log(e);
+    catch {
         log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
     }
     return { tvl, amount0, amount1, blockNumber: blockNumber };

package/dist/src/engine/dynamicData/utils/getEulerV2Vaults.js

@@ -156,7 +156,7 @@ export async function getEulerV2Vaults(chainId) {
                     const aux = EulerEVKInterface.decodeEventLog("EVaultCreated", log.data, log.topics);
                     const name = (await EulerVault__factory.connect(log.address, providers[chainId]).name()).split(" ");
                     const vaultName = (await fetchEulerVaultName(getAddress(log.address), chainId)) ?? name[name.length - 1];
-                    /** Respect the previous typing */
+                    /** Match previous typing */
                     return {
                         address: log.address.toString(),
                         asset: aux[1].toString(),
@@ -167,8 +167,8 @@ export async function getEulerV2Vaults(chainId) {
                     };
                 }
                 catch {
-                    logger.warn(`issue when fetching data on ${NETWORK_LABELS[chainId]} for vault ${log.address}`);
-                    process.exit(1);
+                    logger.error(`issue when fetching data on ${NETWORK_LABELS[chainId]} for vault ${log.address}`);
+                    return {};
                 }
             }));
             log.info(`fetched ${decodedVaults.length} vaults(s) on ${NETWORK_LABELS[chainId]} between blocks ${fromBlock} and ${toBlock}`);

package/dist/src/engine/opportunityMetadata/implementations/Morpho.js

@@ -12,9 +12,14 @@ export class MorphoMetadata {
             { name: `Lend ${morphoParams.symbolBorrowToken} on ${market}`, action: OpportunityAction.LEND },
         ];
         const subtype = subtypes[subType];
+        const tokens = [{ chainId: computeChainId, address: params.targetToken }];
+        if (subType === MorphoSubCampaignType.META) {
+            const typedParams = params;
+            tokens.push({ chainId: computeChainId, address: typedParams.underlyingToken });
+        }
         return {
             action: subtype.action,
-            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            tokens,
             name: subtype.name,
             mainProtocol: (computeChainId === ChainId.POLYGON ? "compound" : "morpho"),
             depositUrl: MorphoMetadata.generateUrl(computeChainId, params, morphoParams, subType),

package/dist/src/jobs/pendings.d.ts

@@ -1 +1 @@
-export declare const main: () => Promise<void>;
+export declare const main: () => Promise<never>;

package/dist/src/jobs/pendings.js

@@ -233,5 +233,6 @@ export const main = async () => {
     if (failed === 0) {
         await file.delete();
     }
+    process.exit(0);
 };
 main();

package/dist/src/jobs/update-euler-vaults.js

@@ -1,5 +1,6 @@
 import { Redis } from "@/cache";
 import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
+import { logger } from "@/utils/logger";
 (async () => {
     await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
     try {
@@ -9,5 +10,6 @@ import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dy
         console.error(e);
         process.exit(1);
     }
+    logger.info("✅ Euler update exited successfully");
     process.exit(0);
 })();

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

@@ -1,5 +1,4 @@
-import type { DynamicDataBuilder } from "@/engine/dynamicData/interface";
-import { Campaign, type CampaignParameters, type ChainId } from "@sdk";
+import { Campaign, type CampaignDynamicData, type CampaignParameters, type ChainId } from "@sdk";
 import { Campaign as CampaignEnum } from "@sdk";
 export declare class DynamicDataService {
     static queryERC20DynamicData(chainId: ChainId, tokenAddress: string, decimals?: number): Promise<{
@@ -10,7 +9,7 @@ export declare class DynamicDataService {
         priceTargetToken: number;
         type: string;
     }>;
-    static getDynamicData(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign, chainId: number): Promise<DynamicDataBuilder<typeof type>[]>;
+    static getDynamicData(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign, chainId: number): Promise<CampaignDynamicData<CampaignEnum>[]>;
     static updateForCampaignType(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign, dryRun?: boolean): Promise<unknown[]>;
     static updateForCampaigns(campaigns: CampaignParameters<CampaignEnum>[], dryRun?: boolean): Promise<unknown[]>;
 }

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

@@ -53,36 +53,34 @@ export class DynamicDataService {
         };
     }
     static async getDynamicData(campaigns, type, chainId) {
+        // Base case: empty input
+        if (campaigns.length === 0)
+            return [];
         try {
-            const dynamicData = await dynamicDataBuilderFactory(typeof type === "number" ? type : Campaign[type]).build(chainId, campaigns);
-            return dynamicData;
+            const campaignType = typeof type === "number" ? type : Campaign[type];
+            return await dynamicDataBuilderFactory(campaignType).build(chainId, campaigns);
         }
-        catch (_err) {
-            console.log("Failed to get dynamic data");
-            const firstHalf = campaigns.splice(0, Math.ceil(campaigns.length / 2));
-            console.log("firstHalf", firstHalf);
-            const secondHalf = campaigns;
-            if (firstHalf.length > 1 || secondHalf.length > 1)
-                return [
-                    ...(await DynamicDataService.getDynamicData(firstHalf, type, chainId)),
-                    ...(await DynamicDataService.getDynamicData(secondHalf, type, chainId)),
-                ];
-            if (firstHalf.length <= 1)
-                console.error(`Failed to get dynamic data for ${firstHalf[0]}`);
-            if (secondHalf.length <= 1)
-                console.error(`Failed to get dynamic data for ${secondHalf[0]}`);
-            return [];
+        catch (error) {
+            // Base case: single failing campaign
+            if (campaigns.length === 1) {
+                log.error(`Permanent failure for campaign ${campaigns[0].campaignId}`, error);
+                return [];
+            }
+            // Recursive binary split
+            const mid = Math.ceil(campaigns.length / 2);
+            const [firstResults, secondResults] = await Promise.all([
+                // Process first half with error propagation
+                DynamicDataService.getDynamicData(campaigns.slice(0, mid), type, chainId),
+                // Process second half with error propagation
+                DynamicDataService.getDynamicData(campaigns.slice(mid), type, chainId),
+            ]);
+            return [...firstResults, ...secondResults];
         }
     }
     static async updateForCampaignType(campaigns, type, dryRun = false) {
         const chainId = campaigns[0].computeChainId;
         const dynamicDataArray = [];
-        const dynamicData = await dynamicDataBuilderFactory(typeof type === "number" ? type : Campaign[type]).build(chainId, campaigns);
-        // const dynamicData = await DynamicDataService.getDynamicData(
-        //   campaigns,
-        //   typeof type === "number" ? type : Campaign[type as keyof typeof Campaign],
-        //   chainId
-        // );
+        const dynamicData = await DynamicDataService.getDynamicData(campaigns, typeof type === "number" ? type : Campaign[type], chainId);
         const oppMap = {};
         for (const data of dynamicData) {
             if (!!data) {
@@ -123,6 +121,7 @@ export class DynamicDataService {
             }
             dynamicDataArray.push(bigintToString({ campaignId: Object.values(entry[1])[0].campaignId, apr, tvl, dailyRewards }));
         }
+        log.info(`[${CampaignEnum[type]}] Updated ${dynamicData.length}/${campaigns.length} campaigns`);
         return dynamicDataArray;
     }
     static async updateForCampaigns(campaigns, dryRun = false) {
@@ -136,7 +135,6 @@ export class DynamicDataService {
         const dynamicDataArray = [];
         for (const [campaignType, campaigns] of campaignTypeToCampaigns.entries()) {
             try {
-                log.info(`updating dynamic data for ${campaigns.length} campaigns of type ${CampaignEnum[campaignType]}`);
                 try {
                     dynamicDataArray.push(await DynamicDataService.updateForCampaignType(campaigns, campaignType, dryRun));
                 }