@merkl/api 0.17.33 → 0.17.35

package/dist/src/backgroundJobs/jobs/opportunityUpdater.d.ts

@@ -1,6 +1,4 @@
 import type Elysia from "elysia";
-export declare const OPPORTUNITY_CACHE = "Opportunities_All";
-export declare const OPPORTUNITY_CACHE_TEST = "Opportunities_Test";
 export declare const opportunityUpdater: (app: Elysia) => Elysia<"", false, {
     decorator: {};
     store: {};

package/dist/src/backgroundJobs/jobs/opportunityUpdater.js

@@ -1,68 +1,16 @@
-import { Redis } from "../../cache";
 import { OpportunityConvertorService } from "../../modules/v4/opportunity/opportunity.converter";
-import { ANGLE_NETWORKS } from "@sdk";
-import { extractIds, getCampaignsFor, splitCampaigns } from "../../entities/campaign";
-import { extractOpportunities } from "../../entities/opportunity";
 import { log } from "../../utils/logger";
-import { Pricer } from "../../utils/pricer";
-export const OPPORTUNITY_CACHE = "Opportunities_All";
-export const OPPORTUNITY_CACHE_TEST = "Opportunities_Test";
-const reduceOpportunities = async (showTest = false) => {
-    const campaigns = await getCampaignsFor(ANGLE_NETWORKS.merkl.map(c => c));
-    const pricer = await Pricer.load();
-    const opportunityIds = extractIds(campaigns);
-    const opportunityCampaigns = splitCampaigns(campaigns, opportunityIds, showTest);
-    const opportunities = {};
-    for (const { id, ...opportunity } of opportunityCampaigns) {
-        const [_, type, mainParameter] = id.split("_");
-        if (!extractOpportunities[type])
-            continue;
-        const { campaigns: oppCampaigns, ...extracted } = extractOpportunities[type](opportunity?.all?.[0], {
-            all: opportunity?.all ?? [],
-            active: opportunity.active ?? [],
-            inactive: opportunity.inactive ?? [],
-        }, pricer?.prices);
-        opportunities[`${type}_${mainParameter}`] = {
-            ...extracted,
-            campaigns: {
-                type: Number.parseInt(type),
-                ids: opportunity?.all?.map(({ campaignId }) => campaignId).filter(c => c),
-            },
-        };
-    }
-    return opportunities;
-};
-const getUpdateBreakdown = (opportunities) => {
-    const total = Object.keys(opportunities)?.length;
-    const totalByChain = Object.entries(opportunities).reduce((prev, [_, { chainId }]) => {
-        prev[chainId] += 1;
-        return prev;
-    }, ANGLE_NETWORKS.merkl.reduce((allChains, chain) => Object.assign(allChains, { [chain]: 0 }), {}));
-    const breakdown = Object.entries(totalByChain).reduce((prev, [chain, count]) => {
-        if (count === 0)
-            return prev;
-        prev[chain] = count;
-        return prev;
-    }, {});
-    return { total, breakdown };
-};
 export const opportunityUpdater = (app) => {
     return app.get("/v3/updateOpportunities", async () => {
-        const opportunities = await reduceOpportunities(false);
-        const opportunitiesWithTest = await reduceOpportunities(true);
-        await Redis.safeSet("Opportunities", opportunities);
-        await Redis.safeSet("OpportunitiesWithTest", opportunitiesWithTest);
         log.info("✅ opportunity cache updated successfully");
-        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(true, false, undefined, undefined);
+        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(false, false, undefined, undefined);
         await OpportunityConvertorService.setV3Opportunities(false, false, undefined, undefined);
         log.info("✅ opportunity v3 cache updated successfully");
-        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(true, true, undefined, undefined);
+        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(false, true, undefined, undefined);
         await OpportunityConvertorService.setV3Opportunities(false, true, undefined, undefined);
         log.info("✅ opportunity v3 test cache updated successfully");
         return new Response(JSON.stringify({
             status: "success",
-            all: getUpdateBreakdown(opportunities),
-            test: getUpdateBreakdown(opportunitiesWithTest),
         }), {
             status: 200,
         });

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

@@ -114,7 +114,7 @@ declare const eden: {
                     identifier: string;
                     name: string;
                     status: "PAST" | "LIVE" | "SOON";
-                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                    action: any;
                     tokens: ({
                         symbol: string;
                         name: string | null;
@@ -3531,7 +3531,7 @@ declare const eden: {
                     identifier: string;
                     name: string;
                     status: "PAST" | "LIVE" | "SOON";
-                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                    action: any;
                     tokens: ({
                         symbol: string;
                         name: string | null;
@@ -7725,7 +7725,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             identifier: string;
                             name: string;
                             status: "PAST" | "LIVE" | "SOON";
-                            action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                            action: any;
                             tokens: ({
                                 symbol: string;
                                 name: string | null;
@@ -12648,7 +12648,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     identifier: string;
                     name: string;
                     status: "PAST" | "LIVE" | "SOON";
-                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                    action: any;
                     tokens: ({
                         symbol: string;
                         name: string | null;
@@ -16065,7 +16065,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     identifier: string;
                     name: string;
                     status: "PAST" | "LIVE" | "SOON";
-                    action: import("../../database/api/.generated").$Enums.OpportunityAction;
+                    action: any;
                     tokens: ({
                         symbol: string;
                         name: string | null;

package/dist/src/factories/metadataFactory/factory.d.ts

@@ -0,0 +1,3 @@
+import { Campaign } from "@sdk";
+import type { MetadataBuilder } from "./interface";
+export declare const metadataBuilderFactory: (campaignType: Campaign) => MetadataBuilder<typeof campaignType>;

package/dist/src/factories/metadataFactory/factory.js

@@ -0,0 +1,56 @@
+import { Campaign } from "@sdk";
+import { AjnaMetadata } from "./implementations/Ajna";
+import { AmbientMetadata } from "./implementations/Ambiant";
+import { BadgerMetadata } from "./implementations/Badger";
+import { ClammMetadata } from "./implementations/Clamm";
+import { CompoundMetadata } from "./implementations/Compound";
+import { DefaultMetadata } from "./implementations/Default";
+import { DolomiteMetadata } from "./implementations/Dolomite";
+import { EigenLayerMetadata } from "./implementations/EigenLayer";
+import { EncompassingMetadata } from "./implementations/Encompassing";
+import { Erc20Metadata } from "./implementations/Erc20";
+import { EulerMetadata } from "./implementations/Euler";
+import { EventBasedMetadata } from "./implementations/EventBased";
+import { HyperdriveMetadata } from "./implementations/Hyperdrive";
+import { InvalidMetadata } from "./implementations/Invalid";
+import { IonMetadata } from "./implementations/Ion";
+import { JsonAirdropMetadata } from "./implementations/JsonAirdrop";
+import { MorphoMetadata } from "./implementations/Morpho";
+import { RadiantMetadata } from "./implementations/Radiant";
+import { SiloMetadata } from "./implementations/Silo";
+import { UniswapV4Metadata } from "./implementations/UniswapV4Metadata";
+import { VestMetadata } from "./implementations/Vest";
+// @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 metadata builder is not implemented
+const map = {
+    [Campaign.INVALID]: new InvalidMetadata(),
+    [Campaign.ERC20]: new Erc20Metadata(),
+    [Campaign.CLAMM]: new ClammMetadata(),
+    [Campaign.ERC20_SNAPSHOT]: new Erc20Metadata(),
+    [Campaign.JSON_AIRDROP]: new JsonAirdropMetadata(),
+    [Campaign.SILO]: new SiloMetadata(),
+    [Campaign.RADIANT]: new RadiantMetadata(),
+    [Campaign.DOLOMITE]: new DolomiteMetadata(),
+    [Campaign.BADGER]: new BadgerMetadata(),
+    [Campaign.AJNA]: new AjnaMetadata(),
+    [Campaign.EULER]: new EulerMetadata(),
+    [Campaign.COMPOUND]: new CompoundMetadata(),
+    [Campaign.ION]: new IonMetadata(),
+    [Campaign.MORPHO]: new MorphoMetadata(),
+    [Campaign.HYPERDRIVELOGFIXPROCESSOR]: new HyperdriveMetadata(),
+    [Campaign.HYPERDRIVELOGPROCESSOR]: new HyperdriveMetadata(),
+    [Campaign.ERC20_FIX_APR]: new Erc20Metadata(),
+    [Campaign.UNISWAP_V4]: new UniswapV4Metadata(),
+    [Campaign.EIGENLAYER]: new EigenLayerMetadata(),
+    [Campaign.VEST]: new VestMetadata(),
+    [Campaign.ERC20LOGPROCESSOR]: new Erc20Metadata(),
+    [Campaign.ERC20REBASELOGPROCESSOR]: new Erc20Metadata(),
+    [Campaign.ERC20TRANSFERS]: new DefaultMetadata(), // TODO
+    [Campaign.M0]: new DefaultMetadata(), // TODO
+    [Campaign.MORPHOSUPPLY]: new DefaultMetadata(), // TODO
+    [Campaign.SYNCSWAP_VAULT]: new DefaultMetadata(), // TODO
+    [Campaign.AMBIENTPROCESSOR]: new AmbientMetadata(),
+    [Campaign.ENCOMPASSING]: new EncompassingMetadata(),
+    [Campaign.EVENT_BASED]: new EventBasedMetadata(),
+};
+export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/factories/metadataFactory/implementations/Ajna.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.AJNA;
+export declare class AjnaMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: `Supply ${any} on ${string}` | `Borrow ${any} on ${string}`;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Ajna.js

@@ -0,0 +1,52 @@
+import { TokenService } from "../../../modules/v4/token/token.service";
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class AjnaMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        try {
+            const [collateral, quote] = await TokenService.getManyOrCreate([
+                {
+                    chainId: computeChainId,
+                    address: params.collateralToken,
+                },
+                {
+                    chainId: computeChainId,
+                    address: params.quoteToken,
+                },
+            ]);
+            if (!collateral || !quote)
+                throw new Error("Failed to fetch tokens");
+            const market = `${params.symbolQuoteToken}/${collateral?.symbol}`;
+            const subtypes = [
+                { name: `Supply ${collateral?.symbol} on ${market}`, action: OpportunityAction.LEND },
+                { name: `Borrow ${quote?.symbol} on ${market}`, action: OpportunityAction.BORROW },
+            ];
+            const subtype = subtypes[subType];
+            return {
+                action: subtype.action,
+                name: subtype.name,
+                tokens: [
+                    { chainId: computeChainId, address: collateral.address },
+                    { chainId: computeChainId, address: quote.address },
+                ],
+                mainProtocol: "ajna",
+            };
+        }
+        catch (_err) {
+            const market = `${params.symbolQuoteToken}/${params.symbolCollateralToken}`;
+            const subtypes = [
+                { name: `Supply ${params.symbolCollateralToken} on ${market}`, action: OpportunityAction.LEND },
+                { name: `Borrow ${params.symbolQuoteToken} on ${market}`, action: OpportunityAction.BORROW },
+            ];
+            const subtype = subtypes[subType];
+            return {
+                action: subtype.action,
+                name: subtype.name,
+                tokens: [
+                    { chainId: computeChainId, address: params.collateralToken },
+                    { chainId: computeChainId, address: params.quoteToken },
+                ],
+                mainProtocol: "ajna",
+            };
+        }
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Ambiant.d.ts

@@ -0,0 +1,15 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.AMBIENTPROCESSOR;
+export declare class AmbientMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        name: string;
+        action: "POOL";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Ambiant.js

@@ -0,0 +1,31 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+import { almName, } from "@sdk";
+import { getAddress } from "viem";
+export class AmbientMetadata {
+    async getMetadata(computeChainId, params, _subType) {
+        const platform = "Ambient";
+        let whitelistNameString = "";
+        if (params.whitelist.length > 0) {
+            for (const whitelist of params.whitelist) {
+                if (whitelistNameString.length > 0) {
+                    whitelistNameString += "or";
+                }
+                const forwarder = params.forwarders.find(x => getAddress(x.sender) === getAddress(whitelist));
+                const forwarderType = forwarder?.type;
+                const forwarderName = !!forwarderType ? almName(forwarderType) : null;
+                if (!!forwarderName) {
+                    whitelistNameString += ` ${forwarderName} `;
+                }
+            }
+        }
+        return {
+            name: `Provide liquidity to ${whitelistNameString} ${platform} ${params.baseToken}-${params.quoteToken}`,
+            action: OpportunityAction.POOL,
+            tokens: [
+                { chainId: computeChainId, address: params.baseToken },
+                { chainId: computeChainId, address: params.quoteToken },
+            ],
+            mainProtocol: "ambient",
+        };
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Badger.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.BADGER;
+export declare class BadgerMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Badger.js

@@ -0,0 +1,25 @@
+import { TokenService } from "../../../modules/v4/token/token.service";
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class BadgerMetadata {
+    async getMetadata(computeChainId, params) {
+        try {
+            const [token] = await TokenService.getManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
+            if (!token)
+                throw new Error("Failed to fetch tokens");
+            return {
+                action: OpportunityAction.BORROW,
+                name: `Borrow ${token.symbol}`,
+                tokens: [{ chainId: computeChainId, address: token?.address }],
+                mainProtocol: "badger",
+            };
+        }
+        catch {
+            return {
+                action: OpportunityAction.BORROW,
+                name: `Borrow ${params.symbolTargetToken}`,
+                tokens: [{ chainId: computeChainId, address: params.targetToken }],
+                mainProtocol: "badger",
+            };
+        }
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Clamm.d.ts

@@ -0,0 +1,15 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.CLAMM;
+export declare class ClammMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        name: string;
+        action: "POOL";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Clamm.js

@@ -0,0 +1,50 @@
+import { camelToKebabCase } from "../../../utils/camelToKebabCase";
+import { OpportunityAction } from "../../../../database/api/.generated";
+import { AMM, ChainId, almName, ammName, } from "@sdk";
+import { getAddress } from "viem";
+export class ClammMetadata {
+    async getMetadata(computeChainId, params) {
+        let platform = ammName(params.amm);
+        if (platform === "BaseSwap") {
+            switch (computeChainId) {
+                case ChainId.MODE:
+                    platform = "SwapMode";
+                    break;
+                case ChainId.ARBITRUM:
+                    platform = "Arbitex";
+                    break;
+                case ChainId.OPTIMISM:
+                    platform = "SuperSwap";
+            }
+        }
+        if (platform === "Izumi") {
+            if (computeChainId === ChainId.ROOTSTOCK)
+                platform = "WoodSwap";
+            else
+                platform = "iZUMi";
+        }
+        let whitelistNameString = "";
+        if (params.whitelist.length > 0) {
+            for (const whitelist of params.whitelist) {
+                if (whitelistNameString.length > 0) {
+                    whitelistNameString += "or";
+                }
+                const forwarder = params.forwarders.find(x => getAddress(x.sender) === getAddress(whitelist));
+                const forwarderType = forwarder?.type;
+                const forwarderName = !!forwarderType ? almName(forwarderType) : null;
+                if (!!forwarderName) {
+                    whitelistNameString += ` ${forwarderName} `;
+                }
+            }
+        }
+        return {
+            name: `Provide liquidity to ${whitelistNameString} ${platform} ${params.symbolToken0}-${params.symbolToken1}${params.poolFee ? ` ${params.poolFee}%` : ""}`,
+            action: OpportunityAction.POOL,
+            tokens: [
+                { chainId: computeChainId, address: params.token0 },
+                { chainId: computeChainId, address: params.token1 },
+            ],
+            mainProtocol: camelToKebabCase(AMM[params.amm]),
+        };
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Compound.d.ts

@@ -0,0 +1,16 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { ProtocolId } from "../../../modules/v4/protocol";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.COMPOUND;
+export declare class CompoundMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: ProtocolId;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Compound.js

@@ -0,0 +1,20 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+import { CompFork, CompoundSubCampaignType, } from "@sdk";
+export class CompoundMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        return {
+            action: subType === CompoundSubCampaignType.supply ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [
+                subType === CompoundSubCampaignType.supply
+                    ? `Supply ${params.symbolUnderlyingToken} on`
+                    : `Borrow ${params.symbolUnderlyingToken} on`,
+                CompFork[params.compFork],
+            ].join(" "),
+            tokens: [
+                { chainId: computeChainId, address: params.underlyingToken },
+                { chainId: computeChainId, address: params.targetToken },
+            ],
+            mainProtocol: CompFork[params.compFork].toLowerCase(),
+        };
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Default.d.ts

@@ -0,0 +1,13 @@
+import type { Campaign as CampaignEnum } from "@sdk";
+import type { CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum;
+export declare class DefaultMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(_computeChainId: ChainId, _params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: never[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Default.js

@@ -0,0 +1,11 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class DefaultMetadata {
+    async getMetadata(_computeChainId, _params) {
+        return {
+            action: OpportunityAction.HOLD,
+            name: "Reward Opportunity",
+            tokens: [],
+            mainProtocol: "",
+        };
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Dolomite.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.DOLOMITE;
+export declare class DolomiteMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        name: string;
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Dolomite.js

@@ -0,0 +1,17 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class DolomiteMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        const subtypes = [
+            { name: "Supply (delta)", action: OpportunityAction.LEND },
+            { name: "Supply", action: OpportunityAction.LEND },
+            { name: "Borrow", action: OpportunityAction.BORROW },
+        ];
+        const subtype = subtypes[subType];
+        return {
+            action: subtype.action,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            name: `${subtype.name} ${params.symbolTargetToken}`,
+            mainProtocol: "dolomite",
+        };
+    }
+}

package/dist/src/factories/metadataFactory/implementations/EigenLayer.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.EIGENLAYER;
+export declare class EigenLayerMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "LEND";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/EigenLayer.js

@@ -0,0 +1,11 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class EigenLayerMetadata {
+    async getMetadata(computeChainId, params) {
+        return {
+            action: OpportunityAction.LEND,
+            name: ["EigenLayer", "strategy for", params.symbolUnderlyingToken].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.underlyingToken }],
+            mainProtocol: "eigenlayer",
+        };
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Encompassing.d.ts

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ENCOMPASSING;
+export declare class EncompassingMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string): Promise<{
+        action: "DROP";
+        name: any;
+        tokens: {
+            chainId: ChainId;
+            address: string;
+        }[];
+        mainProtocol: any;
+    }>;
+}
+export {};

package/dist/src/factories/metadataFactory/implementations/Encompassing.js

@@ -0,0 +1,37 @@
+import { log } from "../../../utils/logger";
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class EncompassingMetadata {
+    async getMetadata(computeChainId, params, _subType, rewardTokenAddress) {
+        try {
+            const dataResponse = await fetch(params.dataUrl);
+            if (!dataResponse.ok)
+                throw new Error(`Response status: ${dataResponse.status}`);
+            const data = await dataResponse.json();
+            return {
+                action: OpportunityAction.DROP,
+                name: data.opportunityName ?? `Distribution of ${params.symbolRewardToken}`,
+                tokens: [
+                    {
+                        chainId: computeChainId,
+                        address: rewardTokenAddress,
+                    },
+                ],
+                mainProtocol: data.mainProtocol ?? undefined,
+            };
+        }
+        catch (err) {
+            log.error("failed to fetch data from dataUrl", err);
+            return {
+                action: OpportunityAction.DROP,
+                name: `Distribution of ${params.symbolRewardToken}`,
+                tokens: [
+                    {
+                        chainId: computeChainId,
+                        address: rewardTokenAddress,
+                    },
+                ],
+                mainProtocol: undefined,
+            };
+        }
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Erc20.d.ts

@@ -0,0 +1,15 @@
+import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC20;
+export declare class Erc20Metadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, distributionChainId: ChainId, campaignId: string): Promise<{
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: any;
+    }>;
+}
+export {};