@merkl/api 0.20.106 → 0.20.109

package/dist/src/engine/{opportunityMetadata/implementations/Ambient.js → implementations/Ambient/metadata.js}

@@ -2,7 +2,8 @@ import { OpportunityAction } from "@db/api";
 import { NETWORK_LABELS, almName, } from "@sdk";
 import { getAddress } from "viem";
 export class AmbientMetadata {
-    async build(computeChainId, params, _subType) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         const platform = "Ambient";
         let whitelistNameString = "";
         if (params.whitelist.length > 0) {

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

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

package/dist/src/engine/{campaignTVL/implementations/Ambiant.js → implementations/Ambient/tvl.js}

@@ -1,8 +1,8 @@
 import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
 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";
@@ -121,7 +121,7 @@ async function fetchAmbientPotentialPositions(poolId, chainId) {
     holders = Array.from(new Set(holders.map(h => JSON.stringify(h)))).map(h => JSON.parse(h));
     return holders;
 }
-export class AmbiantCampaignTVLBuilder {
+export class AmbiantTVLBuilder {
     async build(chainId, campaigns) {
         const tvls = [];
         let calls = [];

package/dist/src/engine/{opportunityMetadata/implementations/Badger.d.ts → implementations/Badger/metadata.d.ts}

@@ -1,13 +1,14 @@
+import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
 import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
+import type { MetadataBuilder } from "../../metadata/interface";
 type campaignType = CampaignEnum.BADGER;
 export declare class BadgerMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "BORROW";
         name: string;
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         mainProtocol: ProtocolId;

package/dist/src/engine/{opportunityMetadata/implementations/Badger.js → implementations/Badger/metadata.js}

@@ -1,7 +1,8 @@
 import { TokenService } from "@/modules/v4/token/token.service";
 import { OpportunityAction } from "@db/api";
 export class BadgerMetadata {
-    async build(computeChainId, params) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         try {
             const [token] = await TokenService.findManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
             if (!token)

package/dist/src/engine/{opportunityMetadata/implementations/Clamm.d.ts → implementations/Clamm/metadata.d.ts}

@@ -1,6 +1,7 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
 import { type ProtocolId } from "@/modules/v4/protocol/protocol.model";
 import { type Campaign as CampaignEnum, type CampaignParameters, ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.CLAMM;
 export declare const uniswapV3OkuChains: {
     [ChainId.BLAST]: string;
@@ -28,11 +29,11 @@ export declare const sushiswapv3Chains: {
     [C in ChainId]?: string;
 };
 export declare class ClammMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         name: string;
         action: "POOL";
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         mainProtocol: ProtocolId;

package/dist/src/engine/{opportunityMetadata/implementations/Clamm.js → implementations/Clamm/metadata.js}

@@ -35,7 +35,8 @@ export const sushiswapv3Chains = {
     [ChainId.SKALE]: "skale-europa",
 };
 export class ClammMetadata {
-    async build(computeChainId, params) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         let platform = ammName(params.amm);
         if (platform === "BaseSwap") {
             switch (computeChainId) {

package/dist/src/engine/{opportunityMetadata/implementations/Compound.d.ts → implementations/Compound/metadata.d.ts}

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

package/dist/src/engine/{opportunityMetadata/implementations/Compound.js → implementations/Compound/metadata.js}

@@ -1,8 +1,9 @@
 import { camelToKebabCase } from "@/utils/caseChanges";
 import { OpportunityAction } from "@db/api";
-import { CompFork, CompoundSubCampaignType, } from "@sdk";
+import { CompFork, CompoundSubCampaignType } from "@sdk";
 export class CompoundMetadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        const { params, computeChainId, subType } = campaign;
         return {
             action: subType === CompoundSubCampaignType.supply ? OpportunityAction.LEND : OpportunityAction.BORROW,
             name: [

package/dist/src/engine/{opportunityMetadata/implementations/CompoundV3.d.ts → implementations/CompoundV3/metadata.d.ts}

@@ -1,13 +1,14 @@
-import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import { type Campaign as CampaignEnum } from "@sdk";
 import type { ProtocolId } from "../../../modules/v4/protocol/protocol.model";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.COMPOUND_V3;
 export declare class CompoundV3Metadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";
         name: string;
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         mainProtocol: ProtocolId;

package/dist/src/engine/{opportunityMetadata/implementations/CompoundV3.js → implementations/CompoundV3/metadata.js}

@@ -1,12 +1,13 @@
 import { OpportunityAction } from "@db/api";
 import { CompoundV3SubCampaignType } from "@sdk";
 export class CompoundV3Metadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         const symbolUnderlyingToken = params.symbolTargetToken.slice(1, -2);
         return {
-            action: subType === CompoundV3SubCampaignType.SUPPLY ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            action: params.subCampaignType === CompoundV3SubCampaignType.SUPPLY ? OpportunityAction.LEND : OpportunityAction.BORROW,
             name: [
-                subType === CompoundV3SubCampaignType.SUPPLY
+                params.subCampaignType === CompoundV3SubCampaignType.SUPPLY
                     ? `Supply ${symbolUnderlyingToken} on`
                     : `Borrow ${symbolUnderlyingToken} on`,
                 "Compound V3",

package/dist/src/engine/implementations/Default/metadata.d.ts

@@ -0,0 +1,13 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { Campaign as CampaignEnum } from "@sdk";
+type campaignType = CampaignEnum;
+export declare class DefaultMetadata implements MetadataBuilder<campaignType> {
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: never[];
+        explorerAddress: string;
+    }>;
+}
+export {};

package/dist/src/engine/{opportunityMetadata/implementations/Default.js → implementations/Default/metadata.js}

@@ -1,11 +1,12 @@
 import { OpportunityAction } from "@db/api";
 export class DefaultMetadata {
-    async build(_computeChainId, _params, _subType, rewardTokenAddress) {
+    async build(campaign) {
+        const { rewardToken } = campaign;
         return {
             action: OpportunityAction.HOLD,
             name: "Reward Opportunity",
             tokens: [],
-            explorerAddress: rewardTokenAddress,
+            explorerAddress: rewardToken.address,
         };
     }
 }

package/dist/src/engine/{opportunityMetadata/implementations/Dolomite.d.ts → implementations/Dolomite/metadata.d.ts}

@@ -1,12 +1,13 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
+import type { Campaign as CampaignEnum } from "@sdk";
 type campaignType = CampaignEnum.DOLOMITE;
 export declare class DolomiteMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         name: string;

package/dist/src/engine/{opportunityMetadata/implementations/Dolomite.js → implementations/Dolomite/metadata.js}

@@ -1,13 +1,14 @@
 import { OpportunityAction } from "@db/api";
 import { getAddress } from "viem";
 export class DolomiteMetadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        const { params, computeChainId, subType } = campaign;
         const subtypes = [
             { name: "Supply (delta)", action: OpportunityAction.LEND },
             { name: "Supply", action: OpportunityAction.LEND },
             { name: "Borrow", action: OpportunityAction.BORROW },
         ];
-        const subtype = subtypes[subType];
+        const subtype = subtypes[subType ?? 0];
         return {
             action: subtype.action,
             tokens: [{ chainId: computeChainId, address: params.targetToken }],

package/dist/src/engine/{opportunityMetadata/implementations/EigenLayer.d.ts → implementations/EigenLayer/metadata.d.ts}

@@ -1,13 +1,14 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
+import type { Campaign as CampaignEnum } from "@sdk";
 type campaignType = CampaignEnum.EIGENLAYER;
 export declare class EigenLayerMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND";
         name: string;
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         mainProtocol: ProtocolId;

package/dist/src/engine/{opportunityMetadata/implementations/EigenLayer.js → implementations/EigenLayer/metadata.js}

@@ -1,6 +1,7 @@
 import { OpportunityAction } from "@db/api";
 export class EigenLayerMetadata {
-    async build(computeChainId, params) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         return {
             action: OpportunityAction.LEND,
             name: ["EigenLayer", "strategy for", params.symbolUnderlyingToken].join(" "),

package/dist/src/engine/implementations/Encompassing/metadata.d.ts

@@ -0,0 +1,16 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { Campaign as CampaignEnum } from "@sdk";
+type campaignType = CampaignEnum.ENCOMPASSING;
+export declare class EncompassingMetadata implements MetadataBuilder<campaignType> {
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
+        action: "DROP";
+        name: any;
+        tokens: {
+            chainId: number;
+            address: string;
+        }[];
+        mainProtocol: any;
+    }>;
+}
+export {};

package/dist/src/engine/{opportunityMetadata/implementations/Encompassing.js → implementations/Encompassing/metadata.js}

@@ -2,7 +2,8 @@ import { protocolIdList } from "@/modules/v4/protocol/protocol.model";
 import { log } from "@/utils/logger";
 import { OpportunityAction } from "@db/api";
 export class EncompassingMetadata {
-    async build(computeChainId, params, _subType, rewardTokenAddress) {
+    async build(campaign) {
+        const { params, computeChainId, rewardToken } = campaign;
         try {
             const dataResponse = await fetch(params.dataUrl);
             if (!dataResponse.ok)
@@ -18,7 +19,7 @@ export class EncompassingMetadata {
                 tokens: [
                     {
                         chainId: computeChainId,
-                        address: rewardTokenAddress,
+                        address: rewardToken.address,
                     },
                 ],
                 mainProtocol: data.mainProtocol ?? undefined,
@@ -32,7 +33,7 @@ export class EncompassingMetadata {
                 tokens: [
                     {
                         chainId: computeChainId,
-                        address: rewardTokenAddress,
+                        address: rewardToken.address,
                     },
                 ],
                 mainProtocol: undefined,

package/dist/src/engine/implementations/Erc20/metadata.d.ts

@@ -0,0 +1,29 @@
+import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { OpportunityAction } from "@db/api";
+import type { MetadataBuilder } from "../../metadata/interface";
+type campaignType = Erc20LikeCampaignEnum;
+export declare class Erc20Metadata implements MetadataBuilder<campaignType> {
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">, opportunityIdentifier: string): Promise<{
+        name: string;
+        action: OpportunityAction;
+        tokens: {
+            chainId: number;
+            address: string;
+        }[];
+        mainProtocol?: import("../../../modules/v4/protocol/protocol.model").ProtocolId;
+        depositUrl?: string;
+        explorerAddress?: string;
+    } | {
+        action: import("@db/api").$Enums.OpportunityAction;
+        name: string;
+        tokens: {
+            chainId: number;
+            address: any;
+        }[];
+        mainProtocol: any;
+        depositUrl: string;
+        explorerAddress: `0x${string}`;
+    }>;
+}
+export {};

package/dist/src/engine/{opportunityMetadata/implementations/Erc20/index.js → implementations/Erc20/metadata.js}

@@ -1,20 +1,33 @@
-import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
+import { dynamicDataBuilderFactory } from "@/engine/deprecated/dynamicData/factory";
+import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
 import { log } from "@/utils/logger";
-import { Campaign as CampaignEnum, } from "@sdk";
+import { Campaign as CampaignEnum } from "@sdk";
 import { getAddress } from "viem";
-import { ProtocolService } from "../../../../modules/v4/protocol/protocol.service";
+import { ProtocolService } from "../../../modules/v4/protocol/protocol.service";
+import { detectSubType } from "./subTypes/detect";
+import { erc20SubTypeMetadataBuilderFactory } from "./subTypes/factories";
 export class Erc20Metadata {
-    async build(computeChainId, params, _subType, rewardTokenAddress, distributionChainId, campaignId) {
+    async build(campaign, opportunityIdentifier) {
+        const { params, computeChainId, campaignId, rewardToken, distributionChainId, type } = campaign;
+        const [subType] = await detectSubType(computeChainId, [
+            OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[type], campaign, opportunityIdentifier),
+        ]);
+        log.info(`building metadata for subtype ${subType}`);
+        const builder = erc20SubTypeMetadataBuilderFactory(subType);
+        if (!!builder) {
+            return builder.build(campaign, opportunityIdentifier);
+        }
+        // @deprecated
         let action = "HOLD";
         let name = `Hold ${params.symbolTargetToken}`;
         let mainProtocolId = undefined;
-        let depositUrl = params.url;
+        const depositUrl = params?.url;
         let tokens = [{ chainId: computeChainId, address: params.targetToken }];
         try {
             const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.ERC20).build(computeChainId, [
                 {
                     campaignId,
-                    rewardToken: rewardTokenAddress,
+                    rewardToken: rewardToken.address,
                     amount: "1",
                     chainId: distributionChainId,
                     computeChainId,
@@ -32,7 +45,6 @@ export class Erc20Metadata {
             if (!!protocol) {
                 mainProtocolId = protocol?.id;
             }
-            depositUrl = Erc20Metadata.generateUrl(computeChainId, params, dynamicData);
         }
         catch {
             log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
@@ -49,11 +61,4 @@ export class Erc20Metadata {
             explorerAddress: getAddress(params.targetToken),
         };
     }
-    static generateUrl(_computeChainId, params, dynamicData) {
-        const erc20type = dynamicData.typeInfo?.type;
-        if (erc20type === "gearbox") {
-            return `https://app.gearbox.fi/pools/${params.targetToken}`;
-        }
-        return params.url;
-    }
 }

package/dist/src/engine/{campaignTVL/implementations/Erc20/computeSubTypes.d.ts → implementations/Erc20/subTypes/detect.d.ts}

@@ -1,8 +1,8 @@
-import { type Erc20LikeCampaignEnum, Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
+import { type Erc20LikeCampaignEnum, Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
 import { type CampaignParameters, type MerklChainId } from "@sdk";
 /**
  * @notice Compute the subtypes of the campaigns
  * @warning
  * @dev This function should return an array of length campaigns.length
  */
-export declare const computeSubTypes: (chainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]) => Promise<Erc20SubType[]>;
+export declare const detectSubType: (chainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]) => Promise<Erc20SubType[]>;

package/dist/src/engine/{campaignTVL/implementations/Erc20/computeSubTypes.js → implementations/Erc20/subTypes/detect.js}

@@ -1,8 +1,8 @@
-import { Erc20SubType } from "@/engine/campaignTVL/implementations/Erc20/Erc20SubType";
-import { getTypeFromFactoryAddress } from "@/engine/erc20SubTypeProcessors/helpers/factoryFinder";
-import { getTypeFromAddressChain } from "@/engine/erc20SubTypeProcessors/helpers/hardcoded";
-import { getTypeFromOwnerAddress } from "@/engine/erc20SubTypeProcessors/helpers/ownerFinder";
-import { processNamingConditionsInOrder } from "@/engine/erc20SubTypeProcessors/subtypesRound1";
+import { getTypeFromFactoryAddress } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/factoryFinder";
+import { getTypeFromAddressChain } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/hardcoded";
+import { getTypeFromOwnerAddress } from "@/engine/deprecated/erc20SubTypeProcessors/helpers/ownerFinder";
+import { processNamingConditionsInOrder } from "@/engine/deprecated/erc20SubTypeProcessors/subtypesRound1";
+import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
 import { decodeReturnValue } from "@/utils/decodeCalls";
 import { BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, } from "@sdk";
 /**
@@ -10,7 +10,7 @@ import { BalancerPoolInterface, BalancerV3StablePoolInterface, ChainInteractionS
  * @warning
  * @dev This function should return an array of length campaigns.length
  */
-export const computeSubTypes = async (chainId, campaigns) => {
+export const detectSubType = async (chainId, campaigns) => {
     // 1. Do a generic multicall per campaign to see which functions are supported
     const callsPerCampaign = 7;
     const calls = [];

package/dist/src/engine/implementations/Erc20/subTypes/factories.d.ts

@@ -0,0 +1,5 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import { Erc20SubType } from ".";
+import type { TVLBuilder } from "../../../tvl/interface";
+export declare const erc20SubTypeTVLBuilderFactory: (erc20Subtype: Erc20SubType) => TVLBuilder<any> | null;
+export declare const erc20SubTypeMetadataBuilderFactory: (erc20Subtype: Erc20SubType) => MetadataBuilder<any> | null;

package/dist/src/engine/implementations/Erc20/subTypes/factories.js

@@ -0,0 +1,33 @@
+import { Erc20SubType } from ".";
+import { GearboxMetadata } from "./implementations/gearbox/metadata";
+import { GearboxTVLBuilder } from "./implementations/gearbox/tvl";
+/**
+ * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
+ *
+ * @dev Casts are made to enforce type safety
+ * @dev A type error must be thrown if a new erc20Subtype is added and the corresponding builder is not implemented
+ */
+const tvlMap = {
+    [Erc20SubType.gearbox]: new GearboxTVLBuilder(),
+};
+export const erc20SubTypeTVLBuilderFactory = (erc20Subtype) => {
+    if (!tvlMap[erc20Subtype]) {
+        return null;
+    }
+    return tvlMap[erc20Subtype];
+};
+/**
+ * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
+ *
+ * @dev Casts are made to enforce type safety
+ * @dev A type error must be thrown if a new erc20Subtype is added and the corresponding builder is not implemented
+ */
+const metadataMap = {
+    [Erc20SubType.gearbox]: new GearboxMetadata(),
+};
+export const erc20SubTypeMetadataBuilderFactory = (erc20Subtype) => {
+    if (!metadataMap[erc20Subtype]) {
+        return null;
+    }
+    return metadataMap[erc20Subtype];
+};

package/dist/src/engine/implementations/Erc20/subTypes/implementations/gearbox/metadata.d.ts

@@ -0,0 +1,17 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import type { Erc20LikeCampaignEnum } from "../..";
+export declare class GearboxMetadata implements MetadataBuilder<Erc20LikeCampaignEnum> {
+    build(campaign: Omit<CampaignWithParams<Erc20LikeCampaignEnum>, "manualOverrides">): Promise<{
+        action: "LEND";
+        protocol: ProtocolId;
+        name: string;
+        tokens: {
+            chainId: number;
+            address: any;
+        }[];
+        depositUrl: string;
+        explorerAddress: any;
+    }>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/gearbox/metadata.js

@@ -0,0 +1,21 @@
+import { OpportunityAction } from "@db/api";
+import { ChainInteractionService, GearBoxVault__factory, TokenInteractionService } from "@sdk";
+export class GearboxMetadata {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
+        const { targetToken } = params;
+        const underlyingToken = await GearBoxVault__factory.connect(targetToken, ChainInteractionService(computeChainId).provider()).underlyingToken();
+        const underlyingTokenSymbol = await TokenInteractionService(computeChainId).symbol(underlyingToken);
+        return {
+            action: OpportunityAction.LEND,
+            protocol: "gearbox",
+            name: `Gearbox ${underlyingTokenSymbol} Deposit`,
+            tokens: [
+                { chainId: computeChainId, address: targetToken },
+                { chainId: computeChainId, address: underlyingToken },
+            ],
+            depositUrl: `https://app.gearbox.fi/pools/${params.targetToken}`,
+            explorerAddress: params.targetToken,
+        };
+    }
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/gearbox/tvl.d.ts

@@ -0,0 +1,6 @@
+import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
+import type { TVLBuilder, TVLData } from "@/engine/tvl/interface";
+import { type CampaignParameters, type MerklChainId } from "@sdk";
+export declare class GearboxTVLBuilder implements TVLBuilder<Erc20LikeCampaignEnum> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]): Promise<TVLData<any>>;
+}

package/dist/src/engine/implementations/Erc20/subTypes/implementations/gearbox/tvl.js

@@ -0,0 +1,43 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { TvlType } from "@db/api";
+import { BN2Number, ChainInteractionService, ERC4626Interface, GearboxVaultInterface, bigIntToNumber, } from "@sdk";
+export class GearboxTVLBuilder {
+    async build(computeChainId, campaigns) {
+        const tvls = [];
+        const calls = [];
+        for (const campaign of campaigns) {
+            const { targetToken } = campaign.campaignParameters;
+            calls.push({
+                allowFailure: true,
+                callData: GearboxVaultInterface.encodeFunctionData("underlyingToken"),
+                target: targetToken,
+            }, {
+                allowFailure: true,
+                callData: ERC4626Interface.encodeFunctionData("totalAssets"),
+                target: targetToken,
+            });
+        }
+        const result = await ChainInteractionService(computeChainId).fetchState(calls);
+        for (const [index, campaign] of campaigns.entries()) {
+            const underlyingTokenAddress = GearboxVaultInterface.decodeFunctionResult("underlyingToken", result[2 * index].returnData)[0];
+            const totalAssets = ERC4626Interface.decodeFunctionResult("totalAssets", result[2 * index + 1].returnData)[0];
+            const underlyingToken = await TokenService.findUniqueOrThrow({
+                chainId: computeChainId,
+                address: underlyingTokenAddress,
+            });
+            const tvl = (bigIntToNumber(totalAssets, underlyingToken.decimals) ?? 0) * (underlyingToken.price ?? 0);
+            tvls.push({
+                campaign,
+                tvl,
+                tvlBreakdown: [
+                    {
+                        identifier: underlyingToken.id,
+                        type: TvlType.TOKEN,
+                        value: BN2Number(totalAssets, underlyingToken.decimals),
+                    },
+                ],
+            });
+        }
+        return tvls;
+    }
+}

package/dist/src/engine/{campaignTVL/implementations/Erc20/Erc20SubType.d.ts → implementations/Erc20/subTypes/index.d.ts}

@@ -23,9 +23,11 @@ export declare enum Erc20SubType {
     yei_borrowing = "yei_borrowing",
     ironclad_borrowing = "ironclad_borrowing",
     zerolend_borrowing = "zerolend_borrowing",
+    lnd_borrowing = "lnd_borrowing",
     yei_lending = "yei_lending",
     ironclad_lending = "ironclad_lending",
     zerolend_lending = "zerolend_lending",
+    lnd_lending = "lnd_lending",
     aave_borrowing = "aave_borrowing",
     aave_lending = "aave_lending",
     sturdy_aggregator = "sturdy_aggregator",

package/dist/src/engine/{campaignTVL/implementations/Erc20/Erc20SubType.js → implementations/Erc20/subTypes/index.js}

@@ -22,9 +22,11 @@ export var Erc20SubType;
     Erc20SubType["yei_borrowing"] = "yei_borrowing";
     Erc20SubType["ironclad_borrowing"] = "ironclad_borrowing";
     Erc20SubType["zerolend_borrowing"] = "zerolend_borrowing";
+    Erc20SubType["lnd_borrowing"] = "lnd_borrowing";
     Erc20SubType["yei_lending"] = "yei_lending";
     Erc20SubType["ironclad_lending"] = "ironclad_lending";
     Erc20SubType["zerolend_lending"] = "zerolend_lending";
+    Erc20SubType["lnd_lending"] = "lnd_lending";
     Erc20SubType["aave_borrowing"] = "aave_borrowing";
     Erc20SubType["aave_lending"] = "aave_lending";
     Erc20SubType["sturdy_aggregator"] = "sturdy_aggregator";

package/dist/src/engine/implementations/Erc20/tvl.d.ts

@@ -0,0 +1,6 @@
+import type { Erc20LikeCampaignEnum } from "@/engine/implementations/Erc20/subTypes";
+import type { TVLBuilder, TVLData } from "@/engine/tvl/interface";
+import { type CampaignParameters, type MerklChainId } from "@sdk";
+export declare class Erc20TVLBuilder implements TVLBuilder<Erc20LikeCampaignEnum> {
+    build(computeChainId: MerklChainId, campaigns: CampaignParameters<Erc20LikeCampaignEnum>[]): Promise<TVLData<any>>;
+}