@merkl/api 0.20.106 → 0.20.109

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

@@ -0,0 +1,98 @@
+import { Erc20DynamicData } from "@/engine/deprecated/dynamicData/implementations/Erc20";
+import { detectSubType } from "@/engine/implementations/Erc20/subTypes/detect";
+import { log } from "@/utils/logger";
+import { BN2Number, ChainInteractionService, ERC20Interface } from "@sdk";
+import { erc20SubTypeTVLBuilderFactory } from "./subTypes/factories";
+export class Erc20TVLBuilder {
+    async build(computeChainId, campaigns) {
+        const subTypes = await detectSubType(computeChainId, campaigns);
+        let tvls = [];
+        const promises = [];
+        const processSubtype = async (subType) => {
+            const builder = erc20SubTypeTVLBuilderFactory(subType);
+            const campaignsOfSubType = campaigns.filter((_campaign, index) => subTypes[index] === subType);
+            if (!!builder) {
+                log.info(`building TVLs for subtype ${subType}`);
+                const subTypeTVLs = await builder.build(computeChainId, campaignsOfSubType);
+                // Impact blacklist or whitelist
+                const calls = [];
+                for (const { campaign } of subTypeTVLs) {
+                    const { campaignParameters } = campaign;
+                    const { targetToken, whitelist, blacklist } = campaignParameters;
+                    if (whitelist?.length > 0) {
+                        calls.push({
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                            target: targetToken,
+                        });
+                        for (const address of whitelist) {
+                            calls.push({
+                                allowFailure: true,
+                                callData: ERC20Interface.encodeFunctionData("balanceOf", [address]),
+                                target: targetToken,
+                            });
+                        }
+                    }
+                    if (blacklist?.length > 0) {
+                        calls.push({
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                            target: targetToken,
+                        });
+                        for (const address of blacklist) {
+                            calls.push({
+                                allowFailure: true,
+                                callData: ERC20Interface.encodeFunctionData("balanceOf", [address]),
+                                target: targetToken,
+                            });
+                        }
+                    }
+                }
+                const result = await ChainInteractionService(computeChainId).fetchState(calls);
+                let index = 0;
+                for (const [i, { campaign }] of subTypeTVLs.entries()) {
+                    const { campaignParameters } = campaign;
+                    const { whitelist, blacklist } = campaignParameters;
+                    if (whitelist?.length > 0) {
+                        const totalSupply = BigInt(ERC20Interface.decodeFunctionResult("totalSupply", result[index++].returnData)[0].toString());
+                        let whitelistedSupply = 0n;
+                        for (const _address of whitelist) {
+                            whitelistedSupply += BigInt(ERC20Interface.decodeFunctionResult("balanceOf", result[index++].returnData)[0].toString());
+                        }
+                        subTypeTVLs[i].tvl *= BN2Number((whitelistedSupply * 10n ** 6n) / totalSupply, 6);
+                    }
+                    if (blacklist?.length > 0) {
+                        const totalSupply = BigInt(ERC20Interface.decodeFunctionResult("totalSupply", result[index++].returnData)[0].toString());
+                        let blacklistedSupply = totalSupply;
+                        for (const _address of blacklist) {
+                            blacklistedSupply -= BigInt(ERC20Interface.decodeFunctionResult("balanceOf", result[index++].returnData)[0].toString());
+                        }
+                        subTypeTVLs[i].tvl *= BN2Number((blacklistedSupply * 10n ** 6n) / totalSupply, 6);
+                    }
+                }
+                tvls = tvls.concat(subTypeTVLs);
+            }
+            else {
+                // @deprecated In case we don't have the new builder, use the old erc20 dynamic data
+                const dynamicDataList = await new Erc20DynamicData().build(computeChainId, campaignsOfSubType);
+                if (dynamicDataList.length !== campaignsOfSubType.length) {
+                    throw new Error("Erc20TVLBuilder: dynamicDataList.length !== campaignsOfSubType.length");
+                }
+                for (const [index, dynamicData] of dynamicDataList.entries()) {
+                    tvls.push({
+                        campaign: campaignsOfSubType[index],
+                        tvl: dynamicData.tvl,
+                        displayTvl: dynamicData.displayTvl ?? undefined,
+                        tvlBreakdown: [],
+                    });
+                }
+            }
+            return;
+        };
+        for (const subType of new Set(subTypes)) {
+            promises.push(processSubtype(subType));
+        }
+        await Promise.allSettled(promises);
+        return tvls;
+    }
+}

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

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

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

@@ -1,6 +1,7 @@
 import { OpportunityAction } from "@db/api";
 export class Erc20SnapshotMetadata {
-    async build(computeChainId, params) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         return {
             name: ["Get", params.symbolTargetToken, "airdrop"].join(" "),
             action: OpportunityAction.DROP,

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

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

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

@@ -1,6 +1,7 @@
 import { OpportunityAction } from "@db/api";
-export class ERC721Metadata {
-    async build(computeChainId, params) {
+export class Erc721Metadata {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         return {
             action: OpportunityAction.HOLD,
             name: `Hold ${params.symbolTargetToken}`,

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

@@ -0,0 +1,29 @@
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import { type Campaign as CampaignEnum } from "@sdk";
+import type { MetadataBuilder } from "../../metadata/interface";
+type campaignType = CampaignEnum.ERC1155 | CampaignEnum.ERC1155FIXAPR | CampaignEnum.ERC6909 | CampaignEnum.ERC6909FIXAPR;
+export declare class ErcMultiTokenMetadata implements MetadataBuilder<campaignType> {
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: {
+            chainId: number;
+            address: any;
+        }[];
+        explorerAddress: any;
+        mainProtocol: ProtocolId;
+        depositUrl: string;
+    } | {
+        action: "HOLD";
+        name: string;
+        tokens: {
+            chainId: number;
+            address: any;
+        }[];
+        explorerAddress: any;
+        mainProtocol: undefined;
+        depositUrl: undefined;
+    }>;
+}
+export {};

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

@@ -1,9 +1,10 @@
 import { OpportunityAction } from "@db/api";
-import { ChainInteractionService, TokenInteractionService, } from "@sdk";
+import { ChainInteractionService, TokenInteractionService } from "@sdk";
 import { utils } from "ethers";
-export class ERCMultiTokenMetadata {
-    async build(computeChainId, params) {
-        const { targetToken, tokenId } = params;
+export class ErcMultiTokenMetadata {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
+        const { tokenId, targetToken } = params;
         // Sonic Market Case
         try {
             const BOOK_MANAGER = "0xD4aD5Ed9E1436904624b6dB8B1BE31f36317C636";

package/dist/src/engine/{opportunityMetadata/implementations/Euler.d.ts → implementations/Euler/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 { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.EULER;
 export declare class EulerMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, distributionChainId: ChainId, campaignId: string): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         name: string;
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         action: "LEND" | "BORROW";

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

@@ -1,17 +1,18 @@
-import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
+import { dynamicDataBuilderFactory } from "@/engine/deprecated/dynamicData/factory";
 import { log } from "@/utils/logger";
 import { sanitizeChainName } from "@/utils/sanitizeChain";
 import { OpportunityAction } from "@db/api";
 import { Campaign as CampaignEnum } from "@sdk";
 import { getAddress } from "viem";
 export class EulerMetadata {
-    async build(computeChainId, params, subType, rewardTokenAddress, distributionChainId, campaignId) {
+    async build(campaign) {
+        const { params, computeChainId, campaignId, rewardToken, distributionChainId, subType } = campaign;
         let name = `Hold ${params.symbolTargetToken}`;
         try {
             const [dynamicData] = await dynamicDataBuilderFactory(CampaignEnum.EULER).build(computeChainId, [
                 {
                     campaignId,
-                    rewardToken: rewardTokenAddress,
+                    rewardToken: rewardToken.address,
                     amount: "1",
                     chainId: distributionChainId,
                     computeChainId,
@@ -29,7 +30,7 @@ export class EulerMetadata {
                 { chainId: computeChainId, address: params.targetToken },
                 { chainId: computeChainId, address: params.addressAsset },
             ],
-            action: [OpportunityAction.LEND, OpportunityAction.BORROW, OpportunityAction.BORROW][subType],
+            action: [OpportunityAction.LEND, OpportunityAction.BORROW, OpportunityAction.BORROW][subType ?? 0],
             mainProtocol: "euler",
             depositUrl: EulerMetadata.generateUrl(computeChainId, params),
             explorerAddress: getAddress(params.targetToken),

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

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

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

@@ -1,6 +1,7 @@
 import { capitalize } from "@/utils/caseChanges";
 export class EventBasedMetadata {
-    async build(computeChainId, params, _subType) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         try {
             const action = "SWAP";
             const mainProtocolId = "hanji";

package/dist/src/engine/{opportunityMetadata/implementations/Hyperdrive.d.ts → implementations/Hyperdrive/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, type CampaignParameters, type ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.HYPERDRIVELOGPROCESSOR | CampaignEnum.HYPERDRIVELOGFIXPROCESSOR;
 export declare class HyperdriveMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "POOL" | "LONG" | "SHORT";
         name: string;
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: any;
         }[];
         mainProtocol: ProtocolId;

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

@@ -2,13 +2,14 @@ import { OpportunityAction } from "@db/api";
 import { HyperDriveSubCampaignType } from "@sdk";
 import { getAddress } from "viem";
 export class HyperdriveMetadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        let { params, computeChainId, subType } = campaign;
         const subtypes = [
             { name: "Add Liquidity on", action: OpportunityAction.POOL },
             { name: "Open Long on", action: OpportunityAction.LONG },
             { name: "Open Short on", action: OpportunityAction.SHORT },
         ];
-        if (subType === HyperDriveSubCampaignType.LP) {
+        if (!subType || subType === HyperDriveSubCampaignType.LP) {
             subType = 0;
         }
         const subtypeData = subtypes[subType];

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

@@ -1,5 +1,5 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { Campaign as CampaignEnum } from "@sdk";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.INVALID;
 export declare class InvalidMetadata implements MetadataBuilder<campaignType> {
     build(): Promise<{

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

@@ -1,14 +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 } from "@sdk";
-import type { CampaignParameters, ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.ION;
 export declare class IonMetadata 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/Ion.js → implementations/Ion/metadata.js}

@@ -1,6 +1,7 @@
 import { OpportunityAction } from "@db/api";
 export class IonMetadata {
-    async build(computeChainId, params) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         // TODO this is not finalized at all
         return {
             action: OpportunityAction.LEND,

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

@@ -0,0 +1,24 @@
+import type { MetadataBuilder } from "@/engine/metadata/interface";
+import type { CampaignWithParams } from "@/modules/v4/campaign";
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+type campaignType = CampaignEnum.JSON_AIRDROP;
+export declare class JsonAirdropMetadata implements MetadataBuilder<campaignType> {
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
+        action: "DROP";
+        name: string;
+        tokens: {
+            chainId: number;
+            address: string;
+        }[];
+        mainProtocol: "splice" | "morpho" | "quickswap" | "euler" | "aura" | "poolside" | "gearbox" | "filament" | "fluid" | "compound" | "ionic" | "layerbank" | "moonwell" | "fraxlend" | "fenix" | "ra" | "syncswap" | "beefy" | "aerodrome" | "velodrome" | "curve" | "toros" | "akron" | "enzyme" | "dragonswap" | "koi" | "rfx" | "woofi" | "pendle" | "zkSwapThreePool" | "maha" | "tempest" | "holdstation" | "venus" | "reactor_fusion" | "vicuna" | "curveNPool" | "satlayer" | "veda" | "cian" | "concrete" | "hourglass" | "katana" | "gamma" | "uniswap" | "ambient" | "arthswap" | "base-swap" | "camelot" | "crust" | "horiza" | "izumi" | "kim" | "pancake-swap" | "ramses" | "retro" | "stryke" | "sushi-swap" | "swapr" | "thruster" | "voltage" | "zero" | "supswap" | "zk-swap" | "thirdtrade" | "swap-x" | "balancer" | "cross_curve" | "neptune" | "maverick" | "trader-joe" | "hanji" | "radiant" | "aave" | "ironclad" | "sturdy" | "frax" | "silo" | "dolomite" | "badger" | "ajna" | "ion" | "eigenlayer" | "vest" | "zerolend" | "lnd" | "hyperdrive" | "oku" | "kyo" | "sonex" | "lendle" | "tako-tako" | "equalizer" | "spectra" | "beraborrow" | "superlend" | "avalon" | "iguana" | "xlend" | "sake" | "sonicmarket" | "angles" | "bunni" | "beratrax" | "yei" | "gammaswap" | "uranium" | undefined;
+        depositUrl?: undefined;
+    } | {
+        action: "DROP";
+        name: string;
+        tokens: never[];
+        mainProtocol: "splice" | "morpho" | "quickswap" | "euler" | "aura" | "poolside" | "gearbox" | "filament" | "fluid" | "compound" | "ionic" | "layerbank" | "moonwell" | "fraxlend" | "fenix" | "ra" | "syncswap" | "beefy" | "aerodrome" | "velodrome" | "curve" | "toros" | "akron" | "enzyme" | "dragonswap" | "koi" | "rfx" | "woofi" | "pendle" | "zkSwapThreePool" | "maha" | "tempest" | "holdstation" | "venus" | "reactor_fusion" | "vicuna" | "curveNPool" | "satlayer" | "veda" | "cian" | "concrete" | "hourglass" | "katana" | "gamma" | "uniswap" | "ambient" | "arthswap" | "base-swap" | "camelot" | "crust" | "horiza" | "izumi" | "kim" | "pancake-swap" | "ramses" | "retro" | "stryke" | "sushi-swap" | "swapr" | "thruster" | "voltage" | "zero" | "supswap" | "zk-swap" | "thirdtrade" | "swap-x" | "balancer" | "cross_curve" | "neptune" | "maverick" | "trader-joe" | "hanji" | "radiant" | "aave" | "ironclad" | "sturdy" | "frax" | "silo" | "dolomite" | "badger" | "ajna" | "ion" | "eigenlayer" | "vest" | "zerolend" | "lnd" | "hyperdrive" | "oku" | "kyo" | "sonex" | "lendle" | "tako-tako" | "equalizer" | "spectra" | "beraborrow" | "superlend" | "avalon" | "iguana" | "xlend" | "sake" | "sonicmarket" | "angles" | "bunni" | "beratrax" | "yei" | "gammaswap" | "uranium" | undefined;
+        depositUrl: any;
+    }>;
+    static generateUrl(_computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): any;
+}
+export {};

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

@@ -1,11 +1,12 @@
 import { log } from "@/utils/logger";
 import { OpportunityAction } from "@db/api";
 export class JsonAirdropMetadata {
-    async build(computeChainId, params, _subType, _rewardTokenAddress, _distributionChainId, _campaignId, creator) {
+    async build(campaign) {
+        const { params, computeChainId, creatorAddress } = campaign;
         const ACI = "0xdeadD8aB03075b7FBA81864202a2f59EE25B312b".toLowerCase();
         const aaveDAO = "0x5300A1a15135EA4dc7aD5a167152C01EFc9b192A".toLowerCase();
-        const aciPrefix = creator.toLowerCase() === ACI && "Get Merit rewards -";
-        const aavePrefix = creator.toLowerCase() === aaveDAO && "Get aAMPL distribution -";
+        const aciPrefix = creatorAddress.toLowerCase() === ACI && "Get Merit rewards -";
+        const aavePrefix = creatorAddress.toLowerCase() === aaveDAO && "Get aAMPL distribution -";
         const prefix = aavePrefix ? aavePrefix : aciPrefix ? aciPrefix : "Get airdrop in";
         let tokenAddress;
         try {

package/dist/src/engine/{opportunityMetadata/implementations/Morpho.d.ts → implementations/Morpho/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, type CampaignParameters, ChainId } from "@sdk";
 import type { BigNumberish } from "ethers";
-import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.MORPHO;
 export declare class MorphoMetadata 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/Morpho.js → implementations/Morpho/metadata.js}

@@ -2,7 +2,10 @@ import { OpportunityAction } from "@db/api";
 import { BN2Number, ChainId, MorphoSubCampaignType, NETWORK_LABELS, } from "@sdk";
 import { getAddress } from "viem";
 export class MorphoMetadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        let { params, computeChainId, subType } = campaign;
+        if (!subType)
+            subType = 0;
         const morphoParams = params;
         const market = `${morphoParams.symbolLoanToken}/${morphoParams.symbolBorrowToken} ${morphoParams?.LLTV && BN2Number(morphoParams?.LLTV, 16)}%`;
         const subtypes = [

package/dist/src/engine/{opportunityMetadata/implementations/Radiant.d.ts → implementations/Radiant/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, type CampaignParameters, type ChainId } from "@sdk";
-import type { MetadataBuilder } from "../interface";
+import { type Campaign as CampaignEnum } from "@sdk";
+import type { MetadataBuilder } from "../../metadata/interface";
 type campaignType = CampaignEnum.RADIANT;
 export declare class RadiantMetadata 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/Radiant.js → implementations/Radiant/metadata.js}

@@ -3,7 +3,10 @@ import { OpportunityAction } from "@db/api";
 import { ChainInteractionService, NETWORK_LABELS, RadiantInterface, } from "@sdk";
 import { getAddress } from "viem";
 export class RadiantMetadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        let { params, computeChainId, subType } = campaign;
+        if (!subType)
+            subType = 0;
         const tokens = [{ chainId: computeChainId, address: params.targetToken }];
         try {
             const result = await ChainInteractionService(computeChainId).fetchState([

package/dist/src/engine/{opportunityMetadata/implementations/Silo.d.ts → implementations/Silo/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.SILO;
 export declare class SiloMetadata 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/Silo.js → implementations/Silo/metadata.js}

@@ -1,7 +1,10 @@
 import { OpportunityAction } from "@db/api";
 import { getAddress } from "viem";
 export class SiloMetadata {
-    async build(computeChainId, params, subType) {
+    async build(campaign) {
+        let { params, computeChainId, subType } = campaign;
+        if (!subType)
+            subType = 0;
         let suffix = ["Deposit", "Protected Deposit", "Debt"][subType];
         const assetSymbol = params.symbolTargetToken;
         if (params.forwarders.length === 1 && assetSymbol)

package/dist/src/engine/{opportunityMetadata/implementations/UniswapV4.d.ts → implementations/UniswapV4/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";
 type campaignType = CampaignEnum.UNISWAP_V4;
 export declare class UniswapV4Metadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): 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/UniswapV4.js → implementations/UniswapV4/metadata.js}

@@ -2,7 +2,8 @@ import { sanitizeChainName } from "@/utils/sanitizeChain";
 import { OpportunityAction } from "@db/api";
 import { getAddress } from "viem";
 export class UniswapV4Metadata {
-    async build(computeChainId, params, _subType) {
+    async build(campaign) {
+        const { params, computeChainId } = campaign;
         const whitelistNameString = "";
         //   if (params.whitelist.length > 0) {
         //     for (const whitelist of params.whitelist) {

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

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

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

@@ -1,23 +1,23 @@
 import { BucketService } from "@/modules/v4/bucket/bucket.service";
 import { TokenService } from "@/modules/v4/token/token.service";
+import { log } from "@/utils/logger";
 import { engineDbClient } from "@db";
 import { TvlType } from "@db/api";
 import { BN2Number, ChainInteractionService, NETWORK_LABELS, } from "@sdk";
-import { log } from "../../../utils/logger";
 /**
  * Compute TVL
  * @dev important: using the most recent state save with current prices
  *      it's only an estimate
  */
-async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID) {
+async function computeUniV4PoolTVLFromMostRecentStateSave(computeChainId, poolID) {
     let stateSave;
     let blockNumber;
     let states = {};
     try {
-        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
+        const currentBlock = await ChainInteractionService(computeChainId).getBlockNumber();
         const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
             where: {
-                id: `UniswapV4_${chainId}_${poolID}`,
+                id: `UniswapV4_${computeChainId}_${poolID}`,
                 blockNumber: {
                     lte: currentBlock,
                 },
@@ -31,7 +31,7 @@ async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID) {
         states = stateSave.states;
     }
     catch {
-        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+        log.warn(`merklDynamic data - failed to read a recent state of pool ${poolID} on ${NETWORK_LABELS[computeChainId]}`);
         return { amount0: 0n, amount1: 0n, blockNumber: blockNumber ?? 0 };
     }
     const { fileName } = states;
@@ -47,21 +47,21 @@ async function computeUniV4PoolTVLFromMostRecentStateSave(chainId, poolID) {
         }
     }
     catch {
-        log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[chainId]}`);
+        log.warn(`merklDynamic data - failed to decode state of pool ${poolID} on ${NETWORK_LABELS[computeChainId]}`);
     }
     return { amount0, amount1, blockNumber: blockNumber };
 }
-export class UniswapV4CampaignTVLBuilder {
-    async build(chainId, campaigns) {
+export class UniswapV4TVLBuilder {
+    async build(computeChainId, campaigns) {
         const tvls = [];
         for (const campaign of campaigns) {
-            const { amount0: poolBalanceToken0, amount1: poolBalanceToken1 } = await computeUniV4PoolTVLFromMostRecentStateSave(chainId, campaign.campaignParameters.poolId);
+            const { amount0: poolBalanceToken0, amount1: poolBalanceToken1 } = await computeUniV4PoolTVLFromMostRecentStateSave(computeChainId, campaign.campaignParameters.poolId);
             const token0Id = TokenService.hashId({
-                chainId,
+                chainId: computeChainId,
                 address: campaign.campaignParameters.currency0,
             });
             const token1Id = TokenService.hashId({
-                chainId,
+                chainId: computeChainId,
                 address: campaign.campaignParameters.currency1,
             });
             tvls.push({

package/dist/src/engine/{opportunityMetadata/implementations/Vest.d.ts → implementations/Vest/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.VEST;
 export declare class VestMetadata implements MetadataBuilder<campaignType> {
-    build(computeChainId: ChainId, _params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+    build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND";
         name: string;
         tokens: {
-            chainId: ChainId;
+            chainId: number;
             address: string;
         }[];
         mainProtocol: ProtocolId;