@merkl/api 0.10.251 → 0.10.253

package/dist/src/modules/v4/opportunity/opportunity.controller.js

@@ -19,6 +19,29 @@ export const OpportunityController = new Elysia({
     headers: AuthorizationHeadersDto,
     body: CreateOpportunityDto,
     detail: { hide: true },
+})
+    // ─── Tries to reparse An Opportunity ─────────────────────────────────
+    .post("/:id", async ({ params }) => {
+    try {
+        if (!params.id.includes("-"))
+            return await OpportunityService.recreate(params.id);
+        const [chainId, type, identifier] = params.id.split("-");
+        return await OpportunityService.recreate({
+            chainId: +chainId,
+            type: type,
+            identifier,
+        });
+    }
+    catch (err) {
+        if (err.code && err.code === "P2025")
+            throw new NotFoundError();
+        throw err;
+    }
+}, {
+    beforeHandle: BackOfficeGuard,
+    headers: AuthorizationHeadersDto,
+    params: OpportunityUniqueDto,
+    detail: { hide: true },
 })
     // ─── Get All Opportunities ───────────────────────────────────────────
     .get("/", async ({ query }) => await OpportunityService.getMany(query), {

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

@@ -331,8 +331,10 @@ export declare const CreateOpportunityDto: import("@sinclair/typebox").TObject<{
         address: import("@sinclair/typebox").TString;
         chainId: import("@sinclair/typebox").TNumber;
     }>>;
-    protocols: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-    mainProtocol: import("@sinclair/typebox").TString;
+    protocols: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    mainProtocol: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    depositUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
 }>;
 export declare const OpportunityAggregateFieldDto: import("@sinclair/typebox").TObject<{
     field: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"dailyRewards">[]>;

package/dist/src/modules/v4/opportunity/opportunity.model.js

@@ -78,8 +78,10 @@ export const CreateOpportunityDto = t.Object({
     status: t.Enum(Status),
     action: t.Enum(OpportunityAction),
     tokens: t.Array(TokenDto),
-    protocols: t.Array(t.String()),
-    mainProtocol: t.String(),
+    protocols: t.Optional(t.Array(t.String())),
+    mainProtocol: t.Optional(t.String()),
+    depositUrl: t.Optional(t.String()),
+    tags: t.Optional(t.Array(t.String())),
 });
 export const OpportunityAggregateFieldDto = t.Object({
     field: t.Union(["dailyRewards"].map(v => t.Literal(v))),

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

@@ -6,7 +6,154 @@ import { type TvlRecord } from "../tvl";
 import type { CreateOpportunityModel, GetOpportunitiesQueryModel, UpdateOpportunityModel } from "./opportunity.model";
 export declare abstract class OpportunityRepository {
     #private;
-    static create(newOpp: CreateOpportunityModel): Promise<void>;
+    static upsert(newOpp: CreateOpportunityModel): Promise<void>;
+    static findUnique(id: string): Promise<({
+        Chain: {
+            name: string;
+            id: number;
+            icon: string;
+        };
+        Campaigns: ({
+            RewardToken: {
+                symbol: string;
+                name: string | null;
+                id: string;
+                icon: string;
+                chainId: number;
+                address: string;
+                decimals: number;
+                displaySymbol: string;
+                verified: boolean;
+                isTest: boolean;
+                price: number | null;
+            };
+        } & {
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            id: string;
+            params: Prisma.JsonValue;
+            subType: number | null;
+            startTimestamp: bigint;
+            endTimestamp: bigint;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+            creatorAddress: string;
+        })[];
+        Tokens: {
+            symbol: string;
+            name: string | null;
+            id: string;
+            icon: string;
+            chainId: number;
+            address: string;
+            decimals: number;
+            displaySymbol: string;
+            verified: boolean;
+            isTest: boolean;
+            price: number | null;
+        }[];
+        Protocols: {
+            name: string;
+            url: string;
+            description: string;
+            id: string;
+            tags: string[];
+            icon: string;
+        }[];
+        MainProtocol: {
+            name: string;
+            url: string;
+            description: string;
+            id: string;
+            tags: string[];
+            icon: string;
+        } | null;
+        TvlRecords: ({
+            TvlBreakdown: {
+                type: import("../../../../database/api/.generated").$Enums.TvlType;
+                id: number;
+                identifier: string;
+                value: number;
+                tvlRecordId: string;
+            }[];
+        } & {
+            total: number;
+            id: string;
+            timestamp: bigint;
+            opportunityId: string;
+        })[];
+        AprRecords: ({
+            AprBreakdown: {
+                type: import("../../../../database/api/.generated").$Enums.AprType;
+                id: number;
+                identifier: string;
+                value: number;
+                aprRecordId: string;
+            }[];
+        } & {
+            id: string;
+            timestamp: bigint;
+            opportunityId: string;
+            cumulated: number;
+        })[];
+        DailyRewardsRecords: ({
+            DailyRewardsBreakdown: ({
+                Campaign: {
+                    startTimestamp: bigint;
+                    endTimestamp: bigint;
+                    amount: string;
+                    RewardToken: {
+                        symbol: string;
+                        name: string | null;
+                        id: string;
+                        icon: string;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        displaySymbol: string;
+                        verified: boolean;
+                        isTest: boolean;
+                        price: number | null;
+                    };
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
+                };
+            } & {
+                id: number;
+                value: number;
+                campaignId: string;
+                dailyRewardsRecordId: string;
+            })[];
+        } & {
+            total: number;
+            id: string;
+            timestamp: bigint;
+            opportunityId: string;
+        })[];
+    } & {
+        name: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        id: string;
+        status: import("../../../../database/api/.generated").$Enums.Status;
+        tags: string[];
+        identifier: string;
+        chainId: number;
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        depositUrl: string | null;
+        mainProtocolId: string | null;
+        tvl: number;
+        apr: number;
+        dailyRewards: number;
+    }) | null>;
     static findUniqueOrThrow(id: string): Promise<{
         Chain: {
             name: string;

package/dist/src/modules/v4/opportunity/opportunity.repository.js

@@ -38,33 +38,53 @@ export class OpportunityRepository {
             },
         };
     }
-    static async create(newOpp) {
-        await apiDbClient.opportunity.create({
-            data: {
-                id: newOpp.id,
-                action: newOpp.action,
-                identifier: newOpp.identifier,
-                name: newOpp.name,
-                status: newOpp.status,
-                type: newOpp.type,
-                Chain: { connect: { id: newOpp.chainId } },
-                MainProtocol: { connect: { id: newOpp.mainProtocol } },
-                Protocols: {
-                    connect: newOpp.protocols.map((protocol) => {
-                        return { id: protocol };
-                    }),
-                },
-                Tokens: {
-                    connect: newOpp.tokens.map((token) => {
-                        return {
-                            chainId_address: {
-                                chainId: token.chainId,
-                                address: token.address,
-                            },
-                        };
-                    }),
+    static async upsert(newOpp) {
+        const data = {
+            id: newOpp.id,
+            action: newOpp.action,
+            identifier: newOpp.identifier,
+            name: newOpp.name,
+            status: newOpp.status,
+            type: newOpp.type,
+            Chain: { connect: { id: newOpp.chainId } },
+            MainProtocol: { connect: { id: newOpp.mainProtocol } },
+            Protocols: {
+                connect: (newOpp.protocols ?? []).map((protocol) => {
+                    return { id: protocol };
+                }),
+            },
+            Tokens: {
+                connect: newOpp.tokens.map((token) => {
+                    return {
+                        chainId_address: {
+                            chainId: token.chainId,
+                            address: token.address,
+                        },
+                    };
+                }),
+            },
+        };
+        await apiDbClient.opportunity.upsert({
+            where: { id: newOpp.id },
+            create: data,
+            update: data,
+        });
+    }
+    static async findUnique(id) {
+        return await apiDbClient.opportunity.findUnique({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Chain: true,
+                Campaigns: {
+                    include: {
+                        RewardToken: true,
+                    },
                 },
+                MainProtocol: true,
+                Protocols: true,
+                Tokens: true,
             },
+            where: { id },
         });
     }
     static async findUniqueOrThrow(id) {

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

@@ -11,12 +11,65 @@ export declare abstract class OpportunityService {
      * @returns {Promise<Opportunity|undefined>}
      */
     static create(newOpp: Omit<CreateOpportunityModel, "id">): Promise<void>;
+    static createFromCampaign(campaign: Omit<CreateCampaignModel, "id">): Promise<{
+        id: string;
+        chainId: number;
+        type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER";
+        identifier: string;
+        name: string;
+        status: "PAST" | "LIVE" | "SOON";
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        tokens: ({
+            symbol: string;
+            name: string | null;
+            id: string;
+            icon: string;
+            chainId: number;
+            address: string;
+            decimals: number;
+            verified: boolean;
+            isTest: boolean;
+        } & {
+            price?: number | null | undefined;
+        })[];
+        mainProtocol: "morpho" | "aura" | "poolside" | "gearbox" | "fluid" | "compound" | "ionic" | "layerbank" | "moonwell" | "fenix" | "syncswap" | "beefy" | "aerodrome" | "velodrome" | "curve" | "akron" | "dragonswap" | "koi" | "baseswap" | "zkswap" | "rfx" | "woofi" | "zkSwapThreePool" | "venus" | "reactor_fusion" | "balancer" | "aave" | "arthswap" | "camelot" | "crust" | "horiza" | "izumi" | "kim" | "pancakeswap-v3" | "quickswap-algebra" | "quickswap-uni" | "ramses" | "retro" | "stryke" | "stryke-pcs" | "stryke-sushi" | "sushiswap-v3" | "swapr" | "thruster" | "uniswap-v3" | "voltage" | "zero" | "supswap-v3" | "thirdtrade" | "uniswap-v2" | "syncswap-v3" | "neptune" | "radiant" | "euler" | "sturdy" | "frax" | "silo" | "coumpound" | "dolomite" | "badger" | "ajna" | "ion" | "eigenlayer" | undefined;
+        depositUrl: any;
+        tags: string[];
+    }>;
+    /**
+     * deletes and recreates an opportunity with fresh data
+     */
+    static recreate(opportunityId: string | OpportunityUnique): Promise<{
+        id: string;
+        chainId: number;
+        type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER";
+        identifier: string;
+        name: string;
+        status: "PAST" | "LIVE" | "SOON";
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        tokens: ({
+            symbol: string;
+            name: string | null;
+            id: string;
+            icon: string;
+            chainId: number;
+            address: string;
+            decimals: number;
+            verified: boolean;
+            isTest: boolean;
+        } & {
+            price?: number | null | undefined;
+        })[];
+        mainProtocol: "morpho" | "aura" | "poolside" | "gearbox" | "fluid" | "compound" | "ionic" | "layerbank" | "moonwell" | "fenix" | "syncswap" | "beefy" | "aerodrome" | "velodrome" | "curve" | "akron" | "dragonswap" | "koi" | "baseswap" | "zkswap" | "rfx" | "woofi" | "zkSwapThreePool" | "venus" | "reactor_fusion" | "balancer" | "aave" | "arthswap" | "camelot" | "crust" | "horiza" | "izumi" | "kim" | "pancakeswap-v3" | "quickswap-algebra" | "quickswap-uni" | "ramses" | "retro" | "stryke" | "stryke-pcs" | "stryke-sushi" | "sushiswap-v3" | "swapr" | "thruster" | "uniswap-v3" | "voltage" | "zero" | "supswap-v3" | "thirdtrade" | "uniswap-v2" | "syncswap-v3" | "neptune" | "radiant" | "euler" | "sturdy" | "frax" | "silo" | "coumpound" | "dolomite" | "badger" | "ajna" | "ion" | "eigenlayer" | undefined;
+        depositUrl: any;
+        tags: string[];
+    }>;
     /**
      * build/fetch metadata of a campaign's opportunity
      * @param campaign
      * @returns {OpportunityMetadata}
      */
-    static getMetadata(campaign: CreateCampaignModel): Promise<OpportunityMetadata>;
+    static getMetadata(campaign: Omit<CreateCampaignModel, "id">): Promise<OpportunityMetadata>;
     static updateMetadata(chain: ChainId): Promise<void>;
     static getUniqueWithCampaignsOrThrow(opportunityId: string | OpportunityUnique): Promise<OpportunityWithCampaignsResourceModel>;
     static getUniqueOrThrow(opportunityId: string | OpportunityUnique): Promise<OpportunityResourceModel>;

package/dist/src/modules/v4/opportunity/opportunity.service.js

@@ -1,11 +1,12 @@
 import { NotFoundError } from "../../../errors";
 import { CampaignService } from "../campaign";
 import { log } from "../../../utils/logger";
-import { OpportunityAction, Prisma } from "../../../../database/api/.generated";
+import { OpportunityAction, Prisma, Status } from "../../../../database/api/.generated";
 import { record } from "@elysiajs/opentelemetry";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
 import { TokenService } from "../token";
+import { UserService } from "../user";
 import { OpportunityRepository } from "./opportunity.repository";
 import { getAjnaMetadata } from "./subservices/getAjnaMetadata.service";
 import { getBadgerMetadata } from "./subservices/getBadgerMetadata.service";
@@ -31,7 +32,58 @@ export class OpportunityService {
      */
     static async create(newOpp) {
         const id = OpportunityService.hashId(newOpp);
-        return await OpportunityRepository.create({ ...newOpp, id });
+        return await OpportunityRepository.upsert({ ...newOpp, id });
+    }
+    static async createFromCampaign(campaign) {
+        const metadata = await OpportunityService.getMetadata(campaign);
+        metadata.tags = [...((await UserService.findUnique(campaign.creator))?.tags ?? []), ...(campaign?.tags ?? [])];
+        const opportunityId = OpportunityService.hashId({
+            chainId: campaign.computeChainId,
+            identifier: campaign.opportunityIdentifier,
+            type: campaign.type,
+        });
+        const tokens = (await TokenService.getManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
+        const params = JSON.parse(campaign.params);
+        const opportunity = {
+            id: opportunityId,
+            chainId: campaign.computeChainId,
+            type: campaign.type,
+            identifier: campaign.opportunityIdentifier, // mainParameter
+            name: metadata.name,
+            status: +campaign.startTimestamp >= new Date().getTime() * 1000
+                ? Status.LIVE
+                : +campaign.endTimestamp < new Date().getTime() * 1000
+                    ? Status.PAST
+                    : Status.SOON,
+            action: metadata.action,
+            tokens,
+            mainProtocol: metadata.mainProtocol,
+            depositUrl: !!params.url ? params.url : undefined,
+            tags: metadata.tags,
+        };
+        await OpportunityRepository.upsert(opportunity);
+        return opportunity;
+    }
+    /**
+     * deletes and recreates an opportunity with fresh data
+     */
+    static async recreate(opportunityId) {
+        const id = typeof opportunityId === "string" ? opportunityId : OpportunityService.hashId(opportunityId);
+        const opportunity = await OpportunityRepository.findUnique(id);
+        if (!opportunity)
+            throw new NotFoundError();
+        const firstCampaign = opportunity?.Campaigns[0];
+        return await OpportunityService.createFromCampaign({
+            ...firstCampaign,
+            chainId: firstCampaign.distributionChainId,
+            creator: firstCampaign.creatorAddress,
+            rewardTokenAddress: firstCampaign.RewardToken.address,
+            opportunityIdentifier: opportunity.identifier,
+            subType: firstCampaign.subType ?? undefined,
+            params: JSON.stringify(firstCampaign.params),
+            startTimestamp: firstCampaign.startTimestamp.toString(),
+            endTimestamp: firstCampaign.endTimestamp.toString(),
+        });
     }
     /**
      * build/fetch metadata of a campaign's opportunity
@@ -39,10 +91,9 @@ export class OpportunityService {
      * @returns {OpportunityMetadata}
      */
     static async getMetadata(campaign) {
-        const campaignType = CampaignService.getTypeFromV3(campaign.type);
         const campaignParams = JSON.parse(campaign.params);
         const chainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
-        switch (campaignType) {
+        switch (campaign.type) {
             case "CLAMM":
                 return getClammMetadata(chainId, campaignParams);
             case "ERC20":

package/dist/src/modules/v4/opportunity/subservices/getClammMetadata.service.js

@@ -22,7 +22,7 @@ export const getClammMetadata = (chainId, params) => {
             platform = "iZUMi";
     }
     return {
-        name: `Provide liquidity to ${params.symbolToken0}-${params.symbolToken1}${params.poolFee ? ` ${params.poolFee}%` : ""}`,
+        name: `Provide liquidity to ${platform} ${params.symbolToken0}-${params.symbolToken1}${params.poolFee ? ` ${params.poolFee}%` : ""}`,
         action: OpportunityAction.POOL,
         tokens: [
             { chainId, address: params.token0 },

package/dist/src/modules/v4/opportunity/subservices/getErc20Metadata.service.js

@@ -1,9 +1,12 @@
 import { log } from "../../../../utils/logger";
 import { CampaignType } from "../../../../../database/api/.generated";
 import { CampaignService } from "../../campaign";
+import { ProtocolService } from "../../protocol";
 export const getErc20Metadata = async (chainId, campaignId, rewardToken, amount, params) => {
     let action = "HOLD";
     let name = `Hold ${params.symbolTargetToken}`;
+    let mainProtocolId = undefined;
+    const tokens = [{ chainId, address: params.targetToken }];
     try {
         const [dynamicData] = await CampaignService.fetchDynamicData(chainId, CampaignType.ERC20, [
             {
@@ -13,56 +16,33 @@ export const getErc20Metadata = async (chainId, campaignId, rewardToken, amount,
                 campaignParameters: params,
             },
         ]);
-        const map = {
-            actions: {
-                POOL: [
-                    "uniswapv2",
-                    "velodrome",
-                    "aerodrome",
-                    "balancerGauge",
-                    "balancerPool",
-                    "curve",
-                    "aura",
-                    "akron",
-                    "beefy",
-                    "dragonswap",
-                    "poolside",
-                    "koi",
-                    "pancakeswap",
-                    "tempest",
-                    "cross_curve",
-                    "zkswap",
-                    "maverickBoostedPosition",
-                    "zkSwapThreePool",
-                    "syncswap",
-                    "rfx",
-                ],
-                BORROW: ["radiant_borrow", "aave_borrowing", "euler_borrow", "zerolend_borrowing"],
-                LEND: [
-                    "gearbox",
-                    "compound",
-                    "radiant_lend",
-                    "aave_lending",
-                    "sturdy_aggregator",
-                    "sturdy_silo",
-                    "fraxlend",
-                    "moonwell",
-                    "ionic",
-                    "fluid",
-                    "silostaking",
-                    "euler_lend",
-                    "layerbank",
-                    "zerolend_lending",
-                    "venus",
-                    "woofi",
-                    "reactor_fusion",
-                ],
-            },
-        };
-        action =
-            Object.entries(map.actions).find(([_action, _types]) => _types.includes(dynamicData?.type ?? ""))?.[0] ?? "HOLD";
-        //TODO: /!\ fix this "as any"
+        action = "HOLD"; // In case the protocol doesn't exist, initialize it to HOLD
         name = dynamicData?.typeInfo?.cardName;
+        mainProtocolId = dynamicData?.typeInfo?.protocol?.toLowerCase().replace(" ", "");
+        const protocol = (await ProtocolService.findMany({ id: mainProtocolId }))?.[0];
+        if (!protocol) {
+            mainProtocolId = undefined;
+        }
+        mainProtocolId = protocol?.id;
+        // Case of lending protocols and receipt tokens
+        if (!!dynamicData && !!dynamicData.typeInfo?.underlying) {
+            tokens.push({ chainId, address: dynamicData.typeInfo.underlying });
+        }
+        // Case of perps protocols
+        if (!!dynamicData && !!dynamicData.typeInfo?.shortToken && !!dynamicData.typeInfo?.longToken) {
+            tokens.push({ chainId, address: dynamicData.typeInfo.shortToken });
+            tokens.push({ chainId, address: dynamicData.typeInfo.longToken });
+        }
+        // Case of weird AMMs
+        if (!!dynamicData && !!dynamicData.typeInfo?.tokenA && !!dynamicData.typeInfo?.tokenB) {
+            tokens.push({ chainId, address: dynamicData.typeInfo.tokenA });
+            tokens.push({ chainId, address: dynamicData.typeInfo.tokenB });
+        }
+        // Case of AMMs
+        if (!!dynamicData && !!dynamicData.typeInfo?.token0 && !!dynamicData.typeInfo?.token1) {
+            tokens.push({ chainId, address: dynamicData.typeInfo.token0 });
+            tokens.push({ chainId, address: dynamicData.typeInfo.token1 });
+        }
     }
     catch {
         log.warn(`failed to fetch dynamic data for ERC20 campaign ${campaignId}`);
@@ -70,6 +50,7 @@ export const getErc20Metadata = async (chainId, campaignId, rewardToken, amount,
     return {
         action,
         name,
-        tokens: [{ chainId, address: params.targetToken }],
+        tokens,
+        mainProtocol: mainProtocolId,
     };
 };

package/dist/src/modules/v4/router.d.ts

@@ -26,6 +26,10 @@ export declare const v4: Elysia<"/v4", false, {
                 post: {
                     body: {
                         name?: string | undefined;
+                        tags?: string[] | undefined;
+                        depositUrl?: string | undefined;
+                        protocols?: string[] | undefined;
+                        mainProtocol?: string | undefined;
                         type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER";
                         tokens: {
                             chainId: number;
@@ -35,8 +39,6 @@ export declare const v4: Elysia<"/v4", false, {
                         identifier: string;
                         chainId: number;
                         action: "INVALID" | "POOL" | "HOLD" | "DROP" | "LEND" | "BORROW";
-                        protocols: string[];
-                        mainProtocol: string;
                     };
                     params: {};
                     query: unknown;
@@ -49,6 +51,48 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            ":id": {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            id: string;
+                            chainId: number;
+                            type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER";
+                            identifier: string;
+                            name: string;
+                            status: "PAST" | "LIVE" | "SOON";
+                            action: import("../../../database/api/.generated").$Enums.OpportunityAction;
+                            tokens: ({
+                                symbol: string;
+                                name: string | null;
+                                id: string;
+                                icon: string;
+                                chainId: number;
+                                address: string;
+                                decimals: number;
+                                verified: boolean;
+                                isTest: boolean;
+                            } & {
+                                price?: number | null | undefined;
+                            })[];
+                            mainProtocol: "morpho" | "aura" | "poolside" | "gearbox" | "fluid" | "compound" | "ionic" | "layerbank" | "moonwell" | "fenix" | "syncswap" | "beefy" | "aerodrome" | "velodrome" | "curve" | "akron" | "dragonswap" | "koi" | "baseswap" | "zkswap" | "rfx" | "woofi" | "zkSwapThreePool" | "venus" | "reactor_fusion" | "balancer" | "aave" | "arthswap" | "camelot" | "crust" | "horiza" | "izumi" | "kim" | "pancakeswap-v3" | "quickswap-algebra" | "quickswap-uni" | "ramses" | "retro" | "stryke" | "stryke-pcs" | "stryke-sushi" | "sushiswap-v3" | "swapr" | "thruster" | "uniswap-v3" | "voltage" | "zero" | "supswap-v3" | "thirdtrade" | "uniswap-v2" | "syncswap-v3" | "neptune" | "radiant" | "euler" | "sturdy" | "frax" | "silo" | "coumpound" | "dolomite" | "badger" | "ajna" | "ion" | "eigenlayer" | undefined;
+                            depositUrl: any;
+                            tags: string[];
+                        };
+                    };
+                };
+            };
+        };
     } & {
         opportunities: {
             index: {
@@ -539,7 +583,7 @@ export declare const v4: Elysia<"/v4", false, {
                         tags?: string[] | undefined;
                         identifier?: string | undefined;
                         subType?: number | undefined;
-                        type: number;
+                        type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER";
                         params: string;
                         creator: string;
                         chainId: number;

package/dist/src/modules/v4/token/token.repository.js

@@ -42,9 +42,7 @@ export class TokenRepository {
                     : query.displaySymbol
                         ? [
                             {
-                                displaySymbol: {
-                                    not: "",
-                                },
+                                displaySymbol: "",
                                 symbol: { equals: query.displaySymbol, mode: "insensitive" },
                             },
                             { displaySymbol: { equals: query.displaySymbol, mode: "insensitive" } },

package/dist/src/utils/generateCardName.js

@@ -42,7 +42,7 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
             return `Lend ${cardToken} on ${typeInfo.protocol}`;
         }
         case tokenType.rfx:
-            return `${typeInfo.protocol} ${typeInfo.symbolShortToken}/${typeInfo.symbolLongToken}`;
+            return `Supply ${typeInfo.symbolShortToken}/${typeInfo.symbolLongToken} on ${typeInfo.protocol}`;
         case tokenType.radiant_borrow:
         case tokenType.aave_borrowing:
         case tokenType.yei_borrowing: