@merkl/api 0.20.91 → 0.20.93

package/dist/src/cache/redis.js

@@ -43,6 +43,7 @@ const redisConfig = {
             keepAlive: 5_000,
         },
     password: REDISPASSWORD,
+    pingInterval: 10_000,
 };
 export const redisClient = createClient(redisConfig);
 redisClient.on("error", error => {

package/dist/src/engine/campaignTVL/factory.js

@@ -1,9 +1,11 @@
 import { Campaign } from "@sdk";
 import { AjnaCampaignTVLBuilder } from "./implementations/Ajna";
+import { AmbiantCampaignTVLBuilder } from "./implementations/Ambiant";
 // @dev Casts are made to enforce type safety
 // @dev A type error must be thrown if a new campaign type is added and the corresponding builder is not implemented
 const map = {
     [Campaign.AJNA]: new AjnaCampaignTVLBuilder(),
+    [Campaign.AMBIENTPROCESSOR]: new AmbiantCampaignTVLBuilder(),
 };
 export const campaignDynamicDataBuilderFactory = (campaignType) => {
     if (!map[campaignType]) {

package/dist/src/engine/{dynamicData → campaignTVL}/implementations/Ambiant.d.ts

@@ -1,7 +1,7 @@
 import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
-import type { DynamicDataBuilder } from "../interface";
+import type { CampaignTVLBuilder, TVLData } from "../interface";
 type campaignType = Campaign.AMBIENTPROCESSOR;
-export declare class AmbiantDynamicData implements DynamicDataBuilder<campaignType> {
-    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<AmbientCampaignDynamicData[]>;
+export declare class AmbiantCampaignTVLBuilder implements CampaignTVLBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<TVLData>;
 }
 export {};

package/dist/src/engine/campaignTVL/implementations/Ambiant.js

@@ -0,0 +1,178 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { TvlType } from "@db/api";
+import { AmbientAddresses, AmbientLens, BN2Number, ChainInteractionService, NETWORK_LABELS, subgraphAmbientEndpoints, withRetry, } from "@sdk";
+import request, { gql } from "graphql-request";
+import { log } from "../../../utils/logger";
+var AmbiantPositionType;
+(function (AmbiantPositionType) {
+    AmbiantPositionType["Concentrated"] = "concentrated";
+    AmbiantPositionType["Ambient"] = "ambient";
+    AmbiantPositionType["Knockout"] = "knockout";
+})(AmbiantPositionType || (AmbiantPositionType = {}));
+function encodeCall(chainId, holder) {
+    if (holder.positionType === AmbiantPositionType.Concentrated) {
+        return [
+            {
+                allowFailure: true,
+                callData: AmbientLens.encodeFunctionData("queryRangeTokens", [
+                    holder.owner,
+                    holder.base,
+                    holder.quote,
+                    holder.poolIdx,
+                    holder.lowerTick,
+                    holder.upperTick,
+                ]),
+                target: AmbientAddresses[chainId].CrocQuery,
+            },
+        ];
+    }
+    return [
+        {
+            allowFailure: true,
+            callData: AmbientLens.encodeFunctionData("queryAmbientTokens", [
+                holder.owner,
+                holder.base,
+                holder.quote,
+                holder.poolIdx,
+            ]),
+            target: AmbientAddresses[chainId].CrocQuery,
+        },
+    ];
+}
+async function decodeCall(result, holder) {
+    let amount0 = BigInt(0n);
+    let amount1 = BigInt(0n);
+    if (holder.positionType === AmbiantPositionType.Concentrated) {
+        const resTok = AmbientLens.decodeFunctionResult("queryRangeTokens", result);
+        amount0 = BigInt(resTok[1]);
+        amount1 = BigInt(resTok[2]);
+    }
+    if (holder.positionType === AmbiantPositionType.Ambient) {
+        const resTok = AmbientLens.decodeFunctionResult("queryAmbientTokens", result);
+        amount0 = BigInt(resTok[1]);
+        amount1 = BigInt(resTok[2]);
+    }
+    return { amount0, amount1 };
+}
+async function poolFromCampaign(campaign) {
+    return {
+        id: campaign.campaignParameters.poolId,
+        mainParameter: campaign.mainParameter, // main parameter containes info of poolAddress + AMM (in case its a priority AMM)
+        baseToken: campaign.campaignParameters.baseToken,
+        quoteToken: campaign.campaignParameters.quoteToken,
+        poolIdx: campaign.campaignParameters.poolIdx,
+        potentialHolders: await fetchAmbientPotentialPositions(campaign.campaignParameters.poolId, campaign.computeChainId),
+    };
+}
+const BATCH_NUMBER = 1000;
+const holdersQuery = gql `
+  query LiquidityChanges($poolId: String!, $minId: String!) {
+    liquidityChanges(
+      where: { pool_: { id: $poolId }, id_gt: $minId , positionType_not: "knockout"},
+      first: ${BATCH_NUMBER},
+      orderBy: pool__id
+    ) {
+      id  
+      user
+      positionType
+      bidTick
+      askTick
+      pool {
+        base
+        quote
+        poolIdx
+      }
+    }
+  }
+  `;
+async function fetchAmbientPotentialPositions(poolId, chainId) {
+    let isFullyFetched = false;
+    let holders = [];
+    let minId = "";
+    while (!isFullyFetched) {
+        const data = await withRetry(request, [
+            subgraphAmbientEndpoints[chainId],
+            holdersQuery,
+            {
+                poolId: poolId,
+                minId: minId,
+            },
+        ]);
+        const fetchedHolders = data.liquidityChanges?.map(entry => {
+            return {
+                owner: entry.user,
+                base: entry.pool.base,
+                quote: entry.pool.quote,
+                poolIdx: Number(entry.pool.poolIdx),
+                lowerTick: Number(entry.bidTick),
+                upperTick: Number(entry.askTick),
+                positionType: entry.positionType,
+            };
+        });
+        if (fetchedHolders.length < BATCH_NUMBER) {
+            isFullyFetched = true;
+        }
+        else {
+            minId = data.liquidityChanges[fetchedHolders.length - 1].id;
+        }
+        holders = holders.concat(fetchedHolders);
+    }
+    // Only keep unique positions
+    holders = Array.from(new Set(holders.map(h => JSON.stringify(h)))).map(h => JSON.parse(h));
+    return holders;
+}
+export class AmbiantCampaignTVLBuilder {
+    async build(chainId, campaigns) {
+        const tvls = [];
+        let calls = [];
+        for (const campaign of campaigns) {
+            const pool = await poolFromCampaign(campaign);
+            calls = calls.concat(...pool.potentialHolders.map(holder => encodeCall(chainId, holder)));
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        for (const campaign of campaigns) {
+            const pool = await poolFromCampaign(campaign);
+            let baseTokenBalance = 0n;
+            let quoteTokenBalance = 0n;
+            const prevI = i;
+            try {
+                for (let index = 0; index < pool.potentialHolders.length; index++) {
+                    const res = await decodeCall(result[i++].returnData, pool.potentialHolders[index]);
+                    baseTokenBalance += BigInt(res.amount0);
+                    quoteTokenBalance += BigInt(res.amount1);
+                }
+            }
+            catch {
+                log.warn(`merklDynamic data - failed to decode state of pool ${pool.id} on ${NETWORK_LABELS[chainId]}`);
+                i = prevI + pool.potentialHolders.length;
+            }
+            const baseTokenId = TokenService.hashId({
+                chainId,
+                address: pool.baseToken,
+            });
+            const quoteTokenId = TokenService.hashId({
+                chainId,
+                address: pool.quoteToken,
+            });
+            tvls.push({
+                campaign,
+                tvl: (await TokenService.getValueByTokenId(baseTokenId, baseTokenBalance)) +
+                    (await TokenService.getValueByTokenId(quoteTokenId, quoteTokenBalance)),
+                tvlBreakdown: [
+                    {
+                        identifier: baseTokenId,
+                        type: TvlType.TOKEN,
+                        value: BN2Number(baseTokenBalance, campaign.campaignParameters.decimalsBaseToken),
+                    },
+                    {
+                        identifier: quoteTokenId,
+                        type: TvlType.TOKEN,
+                        value: BN2Number(quoteTokenBalance, campaign.campaignParameters.decimalsQuoteToken),
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/dynamicData/factory.js

@@ -1,6 +1,5 @@
 import { Campaign } from "@sdk";
 import { AjnaDynamicData } from "./implementations/Ajna";
-import { AmbiantDynamicData } from "./implementations/Ambiant";
 import { BadgerDynamicData } from "./implementations/Badger";
 import { ClammDynamicData } from "./implementations/Clamm";
 import { CompoundDynamicData } from "./implementations/Compound";
@@ -26,7 +25,7 @@ const map = {
     [Campaign.INVALID]: new DefaultDynamicData(),
     [Campaign.JSON_AIRDROP]: new DefaultDynamicData(),
     [Campaign.AJNA]: new AjnaDynamicData(),
-    [Campaign.AMBIENTPROCESSOR]: new AmbiantDynamicData(),
+    [Campaign.AMBIENTPROCESSOR]: new DefaultDynamicData(),
     [Campaign.BADGER]: new BadgerDynamicData(),
     [Campaign.CLAMM]: new ClammDynamicData(),
     [Campaign.COMPOUND]: new CompoundDynamicData(),

package/dist/src/jobs/update-analytics.js

@@ -13,7 +13,7 @@ const CAMPAIGNS_BY_CHAINS_DATABASE_ID = "1cbcfed0d48c8001b1ccf5c0900669ea";
 const CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID = "1cecfed0d48c8066b016f580e54a6b33";
 const CAMPAIGNS_BY_TYPES_DATABASE_ID = "1cecfed0d48c80dcb6bccf3ac3889b5b";
 const getCurrentMonthPages = async (databaseId, firstDayOfMonth) => {
-    const pagesToModify = await notion.databases.query({
+    const currentMonthPages = await notion.databases.query({
         database_id: databaseId,
         filter: {
             property: "From",
@@ -22,57 +22,82 @@ const getCurrentMonthPages = async (databaseId, firstDayOfMonth) => {
             },
         },
     });
-    return pagesToModify.results;
+    return currentMonthPages.results;
 };
 const main = async () => {
     const chains = (await ChainService.findMany({})).reduce((prev, curr) => {
         return Object.assign(prev, { [curr.id]: curr.name });
     }, {});
     const today = new Date();
-    const firstDayOfMonth = new Date(today.getFullYear(), today.getMonth(), 1).getTime() / 1000;
+    const firstDayOfMonth = new Date(Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), 1, // Day 1 of the month
+    0, // 0 hours
+    0, // 0 minutes
+    0, // 0 seconds
+    0 // 0 milliseconds
+    )).getTime() / 1000;
     const promises = [
+        // ─── Rewards By Types ────────────────────────────────────────
         CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByType, firstDayOfMonth).then(async (result) => {
-            const pagesToModify = await getCurrentMonthPages(REWARDS_BY_TYPES_DATABASE_ID, firstDayOfMonth);
+            const currentMonthPages = await getCurrentMonthPages(REWARDS_BY_TYPES_DATABASE_ID, firstDayOfMonth);
             const promises = [];
-            if (today.getDate() === 1 || pagesToModify.length === 0) {
-                for (const [type, monthlyTotalRewards] of Object.entries(result)) {
+            // ─── Check If Page Already Exists ────────────────────
+            for (const type of Object.keys(result)) {
+                const page = currentMonthPages.find(page => "properties" in page &&
+                    page.properties.Types.title[0].text.content === type);
+                // ─── If Page Exists, Update It ───────────────
+                if (page) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Rewards: {
+                                type: "number",
+                                number: result[type],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                    // ─── Else, Create It ─────────────────
+                }
+                else {
                     promises.push(notion.pages.create({
                         parent: { type: "database_id", database_id: REWARDS_BY_TYPES_DATABASE_ID },
                         properties: {
-                            Type: {
+                            Types: {
                                 type: "title",
                                 title: [{ type: "text", text: { content: type } }],
                             },
-                            Rewards: { type: "number", number: monthlyTotalRewards },
+                            Rewards: { type: "number", number: result[type] },
                             From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
             }
-            else {
-                for (const page of pagesToModify) {
+            // ─── Run All The Promises In Parallel ────────────────
+            await Promise.all(promises);
+            log.info("Total Distributed by Types data pushed to Notion successfully");
+        }),
+        // ─── Rewards By Chains ───────────────────────────────────────
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, firstDayOfMonth).then(async (result) => {
+            const currentMonthPages = await getCurrentMonthPages(REWARDS_BY_CHAINS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            for (const chain of Object.keys(result)) {
+                const page = currentMonthPages.find(page => "properties" in page &&
+                    page.properties.Chains.title[0].text.content ===
+                        chains[chain]);
+                if (page) {
                     promises.push(notion.pages.update({
                         page_id: page.id,
                         properties: {
                             Rewards: {
                                 type: "number",
-                                number: result[page.properties.Type
-                                    .title[0].text.content],
+                                number: result[chain],
                             },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
-                await Promise.all(promises);
-                log.info("Total Distributed by Type data pushed to Notion successfully");
-            }
-        }),
-        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByChains, firstDayOfMonth).then(async (result) => {
-            const pagesToModify = await getCurrentMonthPages(REWARDS_BY_CHAINS_DATABASE_ID, firstDayOfMonth);
-            const promises = [];
-            if (today.getDate() === 1 || pagesToModify.length === 0) {
-                for (const [chain, monthlyTotalRewards] of Object.entries(result)) {
+                else {
                     promises.push(notion.pages.create({
                         parent: { type: "database_id", database_id: REWARDS_BY_CHAINS_DATABASE_ID },
                         properties: {
@@ -80,54 +105,45 @@ const main = async () => {
                                 type: "title",
                                 title: [{ type: "text", text: { content: chains[chain] } }],
                             },
-                            Rewards: { type: "number", number: monthlyTotalRewards },
+                            Rewards: { type: "number", number: result[chain] },
                             From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
             }
-            else {
-                for (const page of pagesToModify) {
+            await Promise.all(promises);
+            log.info("Total Distributed by Chains data pushed to Notion successfully");
+        }),
+        // ─── Rewards By Protocols ────────────────────────────────────
+        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByProtocol, firstDayOfMonth).then(async (result) => {
+            const currentMonthPages = await getCurrentMonthPages(REWARDS_BY_PROTOCOLS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            for (const protocol of Object.keys(result)) {
+                const page = currentMonthPages.find(page => "properties" in page &&
+                    page.properties.Protocols.title[0].text.content ===
+                        protocol);
+                if (page) {
                     promises.push(notion.pages.update({
                         page_id: page.id,
                         properties: {
                             Rewards: {
                                 type: "number",
-                                number: result[Object.keys(chains).find(key => page.properties.Chains.title[0].text.content === chains[key])],
+                                number: result[page.properties.Protocols.title[0].text.content],
                             },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
-                await Promise.all(promises);
-                log.info("Total Distributed by Chains data pushed to Notion successfully");
-            }
-        }),
-        CacheService.set(TTLPresets.DAY_1, RewardService.getTotalDistributedByProtocol, firstDayOfMonth).then(async (result) => {
-            const pagesToModify = await getCurrentMonthPages(REWARDS_BY_PROTOCOLS_DATABASE_ID, firstDayOfMonth);
-            const promises = [];
-            if (today.getDate() === 1 || pagesToModify.length === 0) {
-                for (const [protocol, monthlyTotalRewards] of Object.entries(result)) {
+                else {
                     promises.push(notion.pages.create({
                         parent: { type: "database_id", database_id: REWARDS_BY_PROTOCOLS_DATABASE_ID },
                         properties: {
                             Protocols: { type: "title", title: [{ type: "text", text: { content: protocol } }] },
-                            Rewards: { type: "number", number: monthlyTotalRewards },
-                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
-                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
-                        },
-                    }));
-                }
-            }
-            else {
-                for (const page of pagesToModify) {
-                    promises.push(notion.pages.update({
-                        page_id: page.id,
-                        properties: {
-                            Rewards: {
-                                type: "number",
-                                number: result[page.properties.Protocols.title[0].text.content],
+                            Rewards: { type: "number", number: result[protocol] },
+                            From: {
+                                type: "date",
+                                date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] },
                             },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
@@ -141,10 +157,25 @@ const main = async () => {
         CacheService.set(TTLPresets.DAY_1, CampaignService.countByChains, {
             createdAfter: new Date(firstDayOfMonth * 1000),
         }).then(async (result) => {
-            const pagesToModify = await getCurrentMonthPages(CAMPAIGNS_BY_CHAINS_DATABASE_ID, firstDayOfMonth);
+            const currentMonthPages = await getCurrentMonthPages(CAMPAIGNS_BY_CHAINS_DATABASE_ID, firstDayOfMonth);
             const promises = [];
-            if (today.getDate() === 1 || pagesToModify.length === 0) {
-                for (const [chain, monthlyTotalCampaigns] of Object.entries(result)) {
+            for (const chain of Object.keys(result)) {
+                const page = currentMonthPages.find(page => "properties" in page &&
+                    page.properties.Chains.title[0].text.content ===
+                        chains[chain]);
+                if (page) {
+                    promises.push(notion.pages.update({
+                        page_id: page.id,
+                        properties: {
+                            Campaigns: {
+                                type: "number",
+                                number: result[Object.keys(chains).find(key => page.properties.Chains.title[0].text.content === chains[key])],
+                            },
+                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
+                        },
+                    }));
+                }
+                else {
                     promises.push(notion.pages.create({
                         parent: { type: "database_id", database_id: CAMPAIGNS_BY_CHAINS_DATABASE_ID },
                         properties: {
@@ -152,37 +183,41 @@ const main = async () => {
                                 type: "title",
                                 title: [{ type: "text", text: { content: chains[chain] } }],
                             },
-                            Campaigns: { type: "number", number: monthlyTotalCampaigns },
-                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
+                            Campaigns: { type: "number", number: result[chain] },
+                            From: {
+                                type: "date",
+                                date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] },
+                            },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
             }
-            else {
-                for (const page of pagesToModify) {
+            await Promise.all(promises);
+            log.info("Campaigns by Chains data pushed to Notion successfully");
+        }),
+        // ─── Campaigns By Protocols ──────────────────────────────────
+        CacheService.set(TTLPresets.DAY_1, CampaignService.countByProtocols, {
+            createdAfter: new Date(firstDayOfMonth * 1000),
+        }).then(async (result) => {
+            const currentMonthPages = await getCurrentMonthPages(CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            for (const protocol of Object.keys(result)) {
+                const page = currentMonthPages.find(page => "properties" in page &&
+                    page.properties.Protocols.title[0].text.content === protocol);
+                if (page) {
                     promises.push(notion.pages.update({
                         page_id: page.id,
                         properties: {
                             Campaigns: {
                                 type: "number",
-                                number: result[Object.keys(chains).find(key => page.properties.Chains.title[0].text.content === chains[key])],
+                                number: result[page.properties.Protocols.title[0].text.content],
                             },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
-            }
-            await Promise.all(promises);
-            log.info("Campaigns by Chains data pushed to Notion successfully");
-        }),
-        CacheService.set(TTLPresets.DAY_1, CampaignService.countByProtocols, {
-            createdAfter: new Date(firstDayOfMonth * 1000),
-        }).then(async (result) => {
-            const pagesToModify = await getCurrentMonthPages(CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID, firstDayOfMonth);
-            const promises = [];
-            if (today.getDate() === 1 || pagesToModify.length === 0) {
-                for (const [protocol, monthlyTotalCampaigns] of Object.entries(result)) {
+                else {
                     promises.push(notion.pages.create({
                         parent: { type: "database_id", database_id: CAMPAIGNS_BY_PROTOCOLS_DATABASE_ID },
                         properties: {
@@ -190,37 +225,38 @@ const main = async () => {
                                 type: "title",
                                 title: [{ type: "text", text: { content: protocol } }],
                             },
-                            Campaigns: { type: "number", number: monthlyTotalCampaigns },
+                            Campaigns: { type: "number", number: result[protocol] },
                             From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
             }
-            else {
-                for (const page of pagesToModify) {
+            await Promise.all(promises);
+            log.info("Campaigns by Protocols data pushed to Notion successfully");
+        }),
+        // ─── Campaigns By Types ──────────────────────────────────────
+        CacheService.set(TTLPresets.DAY_1, CampaignService.countByTypes, {
+            createdAfter: new Date(firstDayOfMonth * 1000),
+        }).then(async (result) => {
+            const currentMonthPages = await getCurrentMonthPages(CAMPAIGNS_BY_TYPES_DATABASE_ID, firstDayOfMonth);
+            const promises = [];
+            for (const type of Object.keys(result)) {
+                const page = currentMonthPages.find(page => "properties" in page &&
+                    page.properties.Types.title[0].text.content === type);
+                if (page) {
                     promises.push(notion.pages.update({
                         page_id: page.id,
                         properties: {
                             Campaigns: {
                                 type: "number",
-                                number: result[page.properties.Protocols.title[0].text.content],
+                                number: result[page.properties.Types.title[0].text.content],
                             },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },
                     }));
                 }
-            }
-            await Promise.all(promises);
-            log.info("Campaigns by Protocols data pushed to Notion successfully");
-        }),
-        CacheService.set(TTLPresets.DAY_1, CampaignService.countByTypes, {
-            createdAfter: new Date(firstDayOfMonth * 1000),
-        }).then(async (result) => {
-            const pagesToModify = await getCurrentMonthPages(CAMPAIGNS_BY_TYPES_DATABASE_ID, firstDayOfMonth);
-            const promises = [];
-            if (today.getDate() === 1 || pagesToModify.length === 0) {
-                for (const [type, monthlyTotalCampaigns] of Object.entries(result)) {
+                else {
                     promises.push(notion.pages.create({
                         parent: { type: "database_id", database_id: CAMPAIGNS_BY_TYPES_DATABASE_ID },
                         properties: {
@@ -228,22 +264,10 @@ const main = async () => {
                                 type: "title",
                                 title: [{ type: "text", text: { content: type } }],
                             },
-                            Campaigns: { type: "number", number: monthlyTotalCampaigns },
-                            From: { type: "date", date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] } },
-                            To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
-                        },
-                    }));
-                }
-            }
-            else {
-                for (const page of pagesToModify) {
-                    promises.push(notion.pages.update({
-                        page_id: page.id,
-                        properties: {
-                            Campaigns: {
-                                type: "number",
-                                number: result[page.properties.Types
-                                    .title[0].text.content],
+                            Campaigns: { type: "number", number: result[type] },
+                            From: {
+                                type: "date",
+                                date: { start: new Date(firstDayOfMonth * 1000).toISOString().split("T")[0] },
                             },
                             To: { type: "date", date: { start: today.toISOString().split("T")[0] } },
                         },

package/dist/src/modules/v4/router.js

@@ -27,6 +27,7 @@ import bigintToString from "@/utils/bigintToString";
 import { opentelemetry } from "@elysiajs/opentelemetry";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { RedisInstrumentation } from "@opentelemetry/instrumentation-redis-4";
 import { AlwaysOffSampler, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { PrismaInstrumentation } from "@prisma/instrumentation";
 import Elysia from "elysia";
@@ -47,9 +48,15 @@ export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
     instrumentations: [
         getNodeAutoInstrumentations({
             "@opentelemetry/instrumentation-redis": { enabled: false },
-            "@opentelemetry/instrumentation-redis-4": { enabled: true },
         }),
         new PrismaInstrumentation(),
+        new RedisInstrumentation({
+            enabled: true,
+            requireParentSpan: false,
+            dbStatementSerializer: (cmdName, cmdArgs) => {
+                return [cmdName, ...cmdArgs].join(" ");
+            },
+        }),
     ],
     serviceName: "merkl-api",
 }))