@merkl/api 0.20.19 → 0.20.21

package/dist/src/eden/index.d.ts

@@ -1195,6 +1195,17 @@ declare const eden: {
                     }>>;
                 };
             }) & {
+                "dynamic-data": {
+                    post: (body: string[], options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                };
                 metadata: {
                     get: (options: {
                         headers: {
@@ -4946,6 +4957,17 @@ declare const eden: {
                     }>>;
                 };
             }) & {
+                "dynamic-data": {
+                    post: (body: string[], options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                };
                 metadata: {
                     get: (options: {
                         headers: {
@@ -9469,6 +9491,22 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            "dry-run": {
+                "dynamic-data": {
+                    post: {
+                        body: string[];
+                        params: {};
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: unknown[];
+                        };
+                    };
+                };
+            };
         } & {
             "dry-run": {
                 metadata: {
@@ -14965,6 +15003,17 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }>>;
                 };
             }) & {
+                "dynamic-data": {
+                    post: (body: string[], options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                };
                 metadata: {
                     get: (options: {
                         headers: {
@@ -18716,6 +18765,17 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }>>;
                 };
             }) & {
+                "dynamic-data": {
+                    post: (body: string[], options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: unknown[];
+                    }>>;
+                };
                 metadata: {
                     get: (options: {
                         headers: {

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/index.d.ts

@@ -1280,6 +1280,22 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            "dry-run": {
+                "dynamic-data": {
+                    post: {
+                        body: string[];
+                        params: {};
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: unknown[];
+                        };
+                    };
+                };
+            };
         } & {
             "dry-run": {
                 metadata: {

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/campaign/campaign.controller.d.ts

@@ -183,6 +183,22 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 };
             };
         };
+    } & {
+        "dry-run": {
+            "dynamic-data": {
+                post: {
+                    body: string[];
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: unknown[];
+                    };
+                };
+            };
+        };
     } & {
         "dry-run": {
             metadata: {

package/dist/src/modules/v4/campaign/campaign.controller.js

@@ -8,7 +8,7 @@ import { throwOnUnsupportedChainId } from "src/utils/throw";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
 import { OpportunityService } from "../opportunity";
 import { OpportunityConvertorService } from "../opportunity/opportunity.converter";
-import { CampaignResourceDto, CampaignUniqueDto, CreateCampaignDto, GetCampaignQueryDto, RemoveManualOverrideDto, UpdateCampaignCreatorDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
+import { CampaignResourceDto, CampaignUniqueDto, CampaignsDto, CreateCampaignDto, GetCampaignQueryDto, RemoveManualOverrideDto, UpdateCampaignCreatorDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Campaigns Controller ────────────────────────────────────────────────────
 export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { tags: ["Campaigns"] } })
@@ -65,6 +65,19 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(Campaign[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
     return await DynamicDataService.updateForCampaigns([campaignV3], true);
 }, { beforeHandle: BackOfficeGuard, headers: AuthorizationHeadersDto, detail: { hide: true } })
+    // ─── Test Dynamic data computation with a list of campaignId ───────────────────────
+    .post("/dynamic-data", async ({ body }) => {
+    const listCampaigns = [];
+    for (const campaignId of body) {
+        const id = (await CampaignService.findMany({ campaignId: campaignId, test: true }))?.[0]?.id;
+        if (!id)
+            throw new NotFoundError();
+        const campaign = await CampaignService.findUniqueOrThrow(id, true);
+        const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(Campaign[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
+        listCampaigns.push(campaignV3);
+    }
+    return await DynamicDataService.updateForCampaigns(listCampaigns, true);
+}, { beforeHandle: BackOfficeGuard, body: CampaignsDto, headers: AuthorizationHeadersDto, detail: { hide: true } })
     // ─── Test Opportunity creation through a campaign Id and a chain ───────────────────────
     // @dev Starts from the engine db to debug opportunity creation failing and preventing the api db to be filled
     .get("/metadata", async ({ query }) => {

package/dist/src/modules/v4/campaign/campaign.model.d.ts

@@ -29,6 +29,7 @@ export declare const CampaignUniqueDto: import("@sinclair/typebox").TObject<{
     distributionChain: import("@sinclair/typebox").TNumber;
     campaignId: import("@sinclair/typebox").TString;
 }>;
+export declare const CampaignsDto: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
 export declare const CampaignResourceDto: import("@sinclair/typebox").TObject<{
     id: import("@sinclair/typebox").TString;
     computeChainId: import("@sinclair/typebox").TNumber;

package/dist/src/modules/v4/campaign/campaign.model.js

@@ -8,6 +8,7 @@ export const CampaignUniqueDto = t.Object({
     distributionChain: t.Numeric(),
     campaignId: t.String(),
 });
+export const CampaignsDto = t.Array(t.String());
 export const CampaignResourceDto = t.Object({
     id: t.String(),
     computeChainId: t.Number(),

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));
                 }

package/dist/src/modules/v4/router.d.ts

@@ -1150,6 +1150,22 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
+        } & {
+            "dry-run": {
+                "dynamic-data": {
+                    post: {
+                        body: string[];
+                        params: {};
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: unknown[];
+                        };
+                    };
+                };
+            };
         } & {
             "dry-run": {
                 metadata: {