@merkl/api 0.18.12 → 0.18.14

package/dist/src/routes/v3/campaigns.js

@@ -1,3 +1,5 @@
+import { Redis } from "@/cache";
+import { removeTestTokens } from "@/entities/campaign";
 import { CampaignService } from "@/modules/v4/campaign";
 import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
 import { ANGLE_NETWORKS, Campaign as CampaignEnum, ChainId, isSupportedChain, registry, } from "@sdk";
@@ -68,30 +70,66 @@ export default (app) => app.get("/campaigns", async ({ query }) => {
             throw new UnsupportedNetwork(chainId);
         }
     }
-    const campaigns = await CampaignService.findMany({
-        distributionChainIds: chainIds,
-        types: !types.length ? undefined : types.map(type => CampaignEnum[type]),
-        status: query.live ? "LIVE" : undefined,
-        creatorTag: query.creatorTag,
-        test: !hideTestTokens,
-        withOpportunity: true,
-    });
-    const res = {};
-    for (const campaign of campaigns) {
-        if (!res[campaign.distributionChainId]) {
-            res[campaign.distributionChainId] = {};
+    if (process.env.FF_OPPORTUNITY === "true") {
+        const campaigns = await CampaignService.findMany({
+            distributionChainIds: chainIds,
+            types: !types.length ? undefined : types.map(type => CampaignEnum[type]),
+            status: query.live ? "LIVE" : undefined,
+            creatorTag: query.creatorTag,
+            test: !hideTestTokens,
+            withOpportunity: true,
+        });
+        const res = {};
+        for (const campaign of campaigns) {
+            if (!res[campaign.distributionChainId]) {
+                res[campaign.distributionChainId] = {};
+            }
+            const opportunityIdentifier = campaign.Opportunity.identifier;
+            const campaignType = CampaignEnum[campaign.type];
+            if (!res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`]) {
+                res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`] = {
+                    ...OpportunityConvertorService.convertV4CampaignToV3(campaignType, campaign, opportunityIdentifier),
+                    apr: campaign.Opportunity.apr,
+                    tvl: campaign.Opportunity.tvl,
+                };
+            }
         }
-        const opportunityIdentifier = campaign.Opportunity.identifier;
-        const campaignType = CampaignEnum[campaign.type];
-        if (!res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`]) {
-            res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`] = {
-                ...OpportunityConvertorService.convertV4CampaignToV3(campaignType, campaign, opportunityIdentifier),
-                apr: campaign.Opportunity.apr,
-                tvl: campaign.Opportunity.tvl,
-            };
+        return res;
+    }
+    const campaignCachePrefix = query.live === true ? "LiveCampaigns" : "Campaigns";
+    const dynamicData = (await Redis.getManyWithArgs(campaignCachePrefix, chainIds)).reduce((prev, allData, index) => {
+        if (!!allData) {
+            prev[chainIds[index]] = Object.keys(allData).reduce((acc, curr) => {
+                if ((types.length === 0 || types.includes(Number.parseInt(curr.split("_")[0]))) &&
+                    (!hideTestTokens || removeTestTokens(allData[curr]))) {
+                    acc[curr] = allData[curr];
+                }
+                return acc;
+            }, {});
+        }
+        return prev;
+    }, {});
+    // Remove everything that doesn't contain the creator tag
+    if (!!query.creatorTag) {
+        for (const c of Object.keys(dynamicData)) {
+            for (const type_mainParam of Object.keys(dynamicData[c])) {
+                for (const campaignId of Object.keys(dynamicData[c][type_mainParam])) {
+                    if (!dynamicData[c][type_mainParam][campaignId]?.tags?.includes(query.creatorTag)) {
+                        delete dynamicData[c][type_mainParam][campaignId];
+                    }
+                }
+                // Delete the type_mainParam if it's empty
+                if (Object.keys(dynamicData[c][type_mainParam]).length === 0) {
+                    delete dynamicData[c][type_mainParam];
+                }
+            }
+            // Delete the c if it's empty
+            if (Object.keys(dynamicData[c]).length === 0) {
+                delete dynamicData[c];
+            }
         }
     }
-    return res;
+    return dynamicData;
 }, {
     query,
     tags: ["Campaigns"],

package/dist/src/routes/v3/router.d.ts

@@ -82,9 +82,8 @@ export declare const v3: Elysia<"/v3", false, {
                 };
                 headers: unknown;
                 response: {
-                    200: {
-                        [x: string]: Record<string, any>;
-                    };
+                    [x: string]: any;
+                    200: any;
                 };
             };
         };

package/dist/src/utils/prices/priceService.js

@@ -26,7 +26,7 @@ export default class PriceService {
         });
     };
     async fetchPrices() {
-        const tokenPriceSources = await PriceSourceService.findManyPriceSources();
+        const tokenPriceSources = await PriceSourceService.findManyPriceSources({});
         /**
          * @description Factory pricer's call to get prices from different sources
          */

package/dist/src/utils/prices/services/erc4626Service.js

@@ -22,7 +22,7 @@ export default class ERC4626Service {
             return res;
         });
         const resolvedPrices = await Promise.all(pricePromises);
-        return resolvedPrices.flat().filter(price => price !== undefined);
+        return resolvedPrices.flat().filter(price => price !== undefined && price !== null);
     }
     async priceCalculation(rate, vaultToken) {
         try {

package/dist/src/utils/throw.d.ts

@@ -1,4 +1,21 @@
 import { type ChainId } from "@sdk";
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
 export declare const throwOnInvalidRequiredAddress: (address: string) => string;
-export declare const throwOnInvalidAddress: (address: string) => string | undefined;
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * Address can be null or undefined
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
+export declare const throwOnInvalidAddress: (address: string | undefined) => string | undefined;
+/**
+ * Use this function to throw an error if the chainId is not supported by Merkl
+ */
 export declare const throwOnUnsupportedChainId: (chainId: ChainId) => void;

package/dist/src/utils/throw.js

@@ -1,6 +1,12 @@
 import { isSupportedChain } from "@sdk";
 import { utils } from "ethers";
 import { InvalidParameter, UnsupportedNetwork } from "./error";
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
 export const throwOnInvalidRequiredAddress = (address) => {
     try {
         if (!address)
@@ -11,6 +17,14 @@ export const throwOnInvalidRequiredAddress = (address) => {
         throw new InvalidParameter(`Address ${address} is invalid`);
     }
 };
+/**
+ * Use this function to throw an error if the address is invalid
+ * and normalize the address to its checksum version
+ *
+ * Address can be null or undefined
+ *
+ * @dev Usage: params.address = throwOnInvalidAddress(params.address);
+ */
 export const throwOnInvalidAddress = (address) => {
     try {
         if (!address)
@@ -21,6 +35,9 @@ export const throwOnInvalidAddress = (address) => {
         throw new InvalidParameter(`Address ${address} is invalid`);
     }
 };
+/**
+ * Use this function to throw an error if the chainId is not supported by Merkl
+ */
 export const throwOnUnsupportedChainId = (chainId) => {
     if (chainId && !isSupportedChain(chainId, "merkl"))
         throw new UnsupportedNetwork(chainId);