@merkl/api 0.17.33 → 0.17.35

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

@@ -0,0 +1,71 @@
+import { log } from "../../../utils/logger";
+import { Campaign as CampaignEnum } from "@sdk";
+import { CampaignService } from "../../../modules/v4/campaign";
+import { ProtocolService } from "../../../modules/v4/protocol";
+export class Erc20Metadata {
+    async getMetadata(computeChainId, params, _subType, rewardTokenAddress, distributionChainId, campaignId) {
+        let action = "HOLD";
+        let name = `Hold ${params.symbolTargetToken}`;
+        let mainProtocolId = undefined;
+        const tokens = [{ chainId: computeChainId, address: params.targetToken }];
+        try {
+            const [dynamicData] = (await CampaignService.fetchDynamicData(computeChainId, CampaignEnum[CampaignEnum.ERC20], [
+                {
+                    campaignId,
+                    rewardToken: rewardTokenAddress,
+                    amount: "1",
+                    chainId: distributionChainId,
+                    computeChainId,
+                    campaignParameters: params,
+                },
+            ]));
+            action = dynamicData?.typeInfo?.action ?? action;
+            name = dynamicData?.typeInfo?.cardName;
+            mainProtocolId = dynamicData?.typeInfo?.protocol?.toLowerCase().replace(" ", "");
+            const protocol = (await ProtocolService.findMany({ id: mainProtocolId }))?.[0];
+            if (!!protocol) {
+                mainProtocolId = protocol?.id;
+            }
+            // Case of lending protocols and receipt tokens
+            if (!!dynamicData && !!dynamicData.typeInfo?.underlying) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.underlying });
+            }
+            // Case of perps protocols
+            if (!!dynamicData && !!dynamicData.typeInfo?.shortToken && !!dynamicData.typeInfo?.longToken) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.shortToken });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.longToken });
+            }
+            // Case of weird AMMs
+            if (!!dynamicData && !!dynamicData.typeInfo?.tokenA && !!dynamicData.typeInfo?.tokenB) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.tokenA });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.tokenB });
+            }
+            // Case of AMMs
+            if (!!dynamicData && !!dynamicData.typeInfo?.token0 && !!dynamicData.typeInfo?.token1) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token0 });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token1 });
+            }
+            // Case of tripools
+            if (!!dynamicData &&
+                !!dynamicData.typeInfo?.token0Address &&
+                !!dynamicData.typeInfo?.token1Address &&
+                !!dynamicData.typeInfo?.token2Address) {
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token0Address });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token1Address });
+                tokens.push({ chainId: computeChainId, address: dynamicData.typeInfo.token2Address });
+            }
+        }
+        catch {
+            log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
+        }
+        if (mainProtocolId === "unknown") {
+            mainProtocolId = undefined;
+        }
+        return {
+            action,
+            name,
+            tokens,
+            mainProtocol: mainProtocolId,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,10 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class Erc20SnapshotMetadata {
+    async getMetadata(computeChainId, params) {
+        return {
+            name: ["Get", params.symbolTargetToken, "airdrop"].join(" "),
+            action: OpportunityAction.DROP,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+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> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"], rewardTokenAddress: string, _distributionChainId: ChainId, campaignId: string): Promise<{
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        action: "LEND" | "BORROW";
+        mainProtocol: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,34 @@
+import { log } from "../../../utils/logger";
+import { OpportunityAction } from "../../../../database/api/.generated";
+import { Campaign as CampaignEnum } from "@sdk";
+import { CampaignService } from "../../../modules/v4/campaign";
+export class EulerMetadata {
+    async getMetadata(computeChainId, params, subType, rewardTokenAddress, _distributionChainId, campaignId) {
+        let name = `Hold ${params.symbolTargetToken}`;
+        try {
+            const [dynamicData] = (await CampaignService.fetchDynamicData(computeChainId, CampaignEnum[CampaignEnum.EULER], [
+                {
+                    campaignSubType: subType,
+                    campaignParameters: params,
+                    computeChainId,
+                    campaignId,
+                    rewardToken: rewardTokenAddress,
+                    amount: "1",
+                },
+            ]));
+            name = dynamicData?.typeInfo?.cardName;
+        }
+        catch {
+            log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
+        }
+        return {
+            name,
+            tokens: [
+                { chainId: computeChainId, address: params.targetToken },
+                { chainId: computeChainId, address: params.addressAsset },
+            ],
+            action: [OpportunityAction.LEND, OpportunityAction.BORROW, OpportunityAction.BORROW][subType],
+            mainProtocol: "euler",
+        };
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+export class EventBasedMetadata {
+    async getMetadata(computeChainId, params, _subType) {
+        try {
+            const action = "INVALID";
+            const mainProtocolId = "Hanji";
+            let name = `${params.eventID.split("(")[0]} on ${mainProtocolId}`;
+            let tokens = [{ chainId: computeChainId, address: params.contract }];
+            if (params.contract === "0xd0bc067cf877f7b76ceb331891331d9e6acda1a7") {
+                name = `Trade USDC/XTZ on ${mainProtocolId}`;
+                tokens = [
+                    { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                    { chainId: computeChainId, address: "0xc9B53AB2679f573e480d01e0f49e2B5CFB7a3EAb" },
+                ];
+            }
+            if (params.contract === "0x65ea4dd7f789c71c0f57ed84b3bdc3062898d3cb") {
+                name = `Trade USDC/ETH on ${mainProtocolId}`;
+                tokens = [
+                    { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                    { chainId: computeChainId, address: "0xfc24f770F94edBca6D6f885E12d4317320BcB401" },
+                ];
+            }
+            if (params.contract === "0xbb6b01d94e3f6ebae8647cb56d544f57928ab758") {
+                name = `Trade USDC/BTC on ${mainProtocolId}`;
+                tokens = [
+                    { chainId: computeChainId, address: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9" },
+                    { chainId: computeChainId, address: "0xbFc94CD2B1E55999Cfc7347a9313e88702B83d0F" },
+                ];
+            }
+            return {
+                action,
+                name,
+                tokens,
+                mainProtocol: mainProtocolId,
+            };
+        }
+        catch (error) {
+            return {
+                action: "INVALID",
+                name: "Event Based Campaign",
+                tokens: [],
+                mainProtocol: undefined,
+            };
+        }
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Hyperdrive.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.HYPERDRIVELOGPROCESSOR | CampaignEnum.HYPERDRIVELOGFIXPROCESSOR;
+export declare class HyperdriveMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "POOL" | "LONG" | "SHORT";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+import { HyperDriveSubCampaignType } from "@sdk";
+export class HyperdriveMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        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) {
+            subType = 0;
+        }
+        const subtypeData = subtypes[subType];
+        return {
+            action: subtypeData.action,
+            name: [subtypeData.name, params.symbolTargetToken].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "hyperdrive",
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { Campaign as CampaignEnum } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.INVALID;
+export declare class InvalidMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(): Promise<{
+        name: string;
+        action: "INVALID";
+        tokens: never[];
+    }>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class InvalidMetadata {
+    async getMetadata() {
+        return {
+            name: "Invalid Campaigns",
+            action: OpportunityAction.INVALID,
+            tokens: [],
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+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> {
+    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/Ion.js

@@ -0,0 +1,15 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class IonMetadata {
+    async getMetadata(computeChainId, params) {
+        // TODO this is not finalized at all
+        return {
+            action: OpportunityAction.LEND,
+            name: ["Ion", "strategy for", params.symbolBorrowToken].join(" "),
+            tokens: [
+                { chainId: computeChainId, address: params.borrowToken },
+                { chainId: computeChainId, address: params.collateralToken },
+            ],
+            mainProtocol: "ion",
+        };
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+import { log } from "../../../utils/logger";
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class JsonAirdropMetadata {
+    async getMetadata(computeChainId, params, _subType, _rewardTokenAddress, _distributionChainId, _campaignId, creator) {
+        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 prefix = aavePrefix ? aavePrefix : aciPrefix ? aciPrefix : "Get airdrop in";
+        let tokenAddress;
+        try {
+            const res = await fetch(params.jsonUrl);
+            if (!res.ok)
+                throw new Error(`Response status: ${res.status}`);
+            tokenAddress = (await res.json()).rewardToken;
+            return {
+                action: OpportunityAction.DROP,
+                name: `${prefix} ${params.symbolRewardToken}`,
+                tokens: [
+                    {
+                        chainId: computeChainId,
+                        address: tokenAddress, // TODO: Make sure targetToken is set
+                    },
+                ],
+                mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,
+            };
+        }
+        catch (err) {
+            log.error("failed to fetch token address on IPFS", err);
+            return {
+                action: OpportunityAction.DROP,
+                name: `${prefix} ${params.symbolRewardToken}`,
+                tokens: [],
+                mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,
+            };
+        }
+    }
+}

package/dist/src/factories/metadataFactory/implementations/Morpho.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.MORPHO;
+export declare class MorphoMetadata implements MetadataBuilder<campaignType> {
+    getMetadata(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        name: `Supply ${string} on ${string}` | `Borrow ${string} on ${string}` | `Deposit in ${string} - Metamorpho` | `Lend ${string} on ${string}`;
+        mainProtocol: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+import { BN2Number } from "@sdk";
+export class MorphoMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        const morphoParams = params;
+        const market = `${morphoParams.symbolLoanToken}/${morphoParams.symbolBorrowToken} ${morphoParams?.LLTV && BN2Number(morphoParams?.LLTV, 16)}%`;
+        const subtypes = [
+            { name: `Deposit in ${morphoParams.nameTargetToken} - Metamorpho`, action: OpportunityAction.LEND },
+            { name: `Supply ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.LEND },
+            { name: `Borrow ${morphoParams.symbolLoanToken} on ${market}`, action: OpportunityAction.BORROW },
+            { name: `Lend ${morphoParams.symbolBorrowToken} on ${market}`, action: OpportunityAction.LEND },
+        ];
+        const subtype = subtypes[subType];
+        return {
+            action: subtype.action,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            name: subtype.name,
+            mainProtocol: "morpho",
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.RADIANT;
+export declare class RadiantMetadata 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: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class RadiantMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        return {
+            action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "radiant",
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.SILO;
+export declare class SiloMetadata 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: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class SiloMetadata {
+    async getMetadata(computeChainId, params, subType) {
+        let suffix = ["Deposit", "Protected Deposit", "Debt"][subType];
+        const assetSymbol = params.symbolTargetToken;
+        if (params.forwarders.length === 1 && assetSymbol)
+            suffix += ` (${assetSymbol} Market)`;
+        return {
+            action: subType <= 1 ? OpportunityAction.LEND : OpportunityAction.BORROW,
+            name: [subType <= 1 ? "Lend" : "Borrow", params.symbolTargetToken, suffix].join(" "),
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: "silo",
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+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> {
+    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/UniswapV4Metadata.js

@@ -0,0 +1,28 @@
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class UniswapV4Metadata {
+    async getMetadata(computeChainId, params, _subType) {
+        const 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 as CLAMMForwarder)?.type;
+        //       const forwarderName = !!forwarderType ? almName(forwarderType) : null;
+        //       if (!!forwarderName) {
+        //         whitelistNameString += ` ${forwarderName} `;
+        //       }
+        //     }
+        //   }
+        return {
+            name: `Provide liquidity to ${whitelistNameString} UniswapV4 ${params.symbolCurrency0}-${params.symbolCurrency1}${params.lpFee ? ` ${params.lpFee}%` : ""}`,
+            action: OpportunityAction.POOL,
+            tokens: [
+                { chainId: computeChainId, address: params.currency0 },
+                { chainId: computeChainId, address: params.currency1 },
+            ],
+            mainProtocol: "uniswapv4",
+        };
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { VEST_TOKEN } from "../../../libs/campaigns/campaignTypes/VestDynamicData";
+import { OpportunityAction } from "../../../../database/api/.generated";
+export class VestMetadata {
+    async getMetadata(computeChainId, _params, _subType) {
+        return {
+            action: OpportunityAction.LEND,
+            name: ["Vest", "supply", "treasury"].join(" "),
+            tokens: [{ chainId: computeChainId, address: VEST_TOKEN }],
+            mainProtocol: "vest",
+        };
+    }
+}

package/dist/src/index.d.ts

@@ -222,7 +222,7 @@ declare const app: Elysia<"", false, {
                             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/modules/v4/opportunity/opportunity.controller.d.ts

@@ -77,7 +77,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                         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/modules/v4/opportunity/opportunity.model.d.ts

@@ -5,7 +5,6 @@ import { type Protocol } from "../protocol/protocol.model";
 import { type DailyRewardsRecord } from "../reward/reward.model";
 import { type Token } from "../token/token.model";
 import { type TvlRecord } from "../tvl/tvl.model";
-import { OpportunityAction } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
 import { type Chain } from "../chain/chain.model";
 import type { OpportunityRepository } from "./opportunity.repository";
@@ -25,16 +24,6 @@ export type Opportunity = Resource<"Opportunity", "mainProtocolId", {
     campaigns?: Campaign["model"][];
 }>;
 export type LightOpportunityFromDB = Omit<Awaited<ReturnType<typeof OpportunityRepository.findUniqueOrThrow>>, "AprRecords" | "TvlRecords" | "DailyRewardsRecords" | "Campaigns">;
-export type OpportunityMetadata = {
-    name: string;
-    action: OpportunityAction;
-    tokens: {
-        chainId: number;
-        address: string;
-    }[];
-    mainProtocol?: string;
-    tags?: string[];
-};
 export type OpportunityUnique = {
     chainId: ChainId;
     type: string;

package/dist/src/modules/v4/opportunity/opportunity.service.d.ts

@@ -33,7 +33,7 @@ export declare abstract class OpportunityService {
         identifier: string;
         name: string;
         status: "SOON";
-        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        action: OpportunityAction;
         mainProtocol: string | undefined;
         depositUrl: any;
         tags: string[];
@@ -45,7 +45,7 @@ export declare abstract class OpportunityService {
         identifier: string;
         name: string;
         status: "PAST" | "LIVE" | "SOON";
-        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        action: OpportunityAction;
         tokens: ({
             symbol: string;
             name: string | null;
@@ -86,7 +86,7 @@ export declare abstract class OpportunityService {
         identifier: string;
         name: string;
         status: "PAST" | "LIVE" | "SOON";
-        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        action: OpportunityAction;
         tokens: {
             price?: number | null | undefined;
             symbol: string;
@@ -113,7 +113,7 @@ export declare abstract class OpportunityService {
         identifier: string;
         name: string;
         status: "PAST" | "LIVE" | "SOON";
-        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        action: OpportunityAction;
         tokens: ({
             symbol: string;
             name: string | null;