@merkl/api 0.10.256 → 0.10.258

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

@@ -427,7 +427,21 @@ declare const eden: {
                     query?: Record<string, unknown> | undefined;
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: void;
+                    200: {
+                        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;
                 }>>;
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -587,7 +601,7 @@ declare const eden: {
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: {
-                        sum: File;
+                        sum: string;
                     };
                 }>>;
             }) & {};
@@ -2952,7 +2966,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         authorization: string;
                     };
                     response: {
-                        200: void;
+                        200: {
+                            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;
                     };
                 };
             };
@@ -3437,7 +3465,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         headers: unknown;
                         response: {
                             200: {
-                                sum: File;
+                                sum: string;
                             };
                         };
                     };
@@ -6710,7 +6738,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query?: Record<string, unknown> | undefined;
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: void;
+                    200: {
+                        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;
                 }>>;
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -6870,7 +6912,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: {
-                        sum: File;
+                        sum: string;
                     };
                 }>>;
             }) & {};

package/dist/src/index.d.ts

@@ -168,7 +168,21 @@ declare const app: Elysia<"", false, {
                         authorization: string;
                     };
                     response: {
-                        200: void;
+                        200: {
+                            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;
                     };
                 };
             };
@@ -653,7 +667,7 @@ declare const app: Elysia<"", false, {
                         headers: unknown;
                         response: {
                             200: {
-                                sum: File;
+                                sum: string;
                             };
                         };
                     };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/curveNPoolProcessor.js

@@ -1,6 +1,10 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { GenericProcessor } from "./GenericProcessor";
+const matchSingleNumber = (input) => {
+    const regex = /^\d+$/;
+    return regex.test(input);
+};
 export class CurveNPoolProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "numberTokens", call: "N_COINS", target: "tokenAddress" }],
@@ -73,6 +77,12 @@ export class CurveNPoolProcessor extends GenericProcessor {
             tvl += amount * price;
         }
         const priceTargetToken = tvl / totalSupply;
+        // Remove all keys that start with a number or balanceToken
+        for (const key in typeInfo) {
+            if (key.startsWith("balanceToken") || key.startsWith("decimalsToken") || matchSingleNumber(key)) {
+                delete typeInfo[key];
+            }
+        }
         return {
             ...typeInfo,
             totalSupply,

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.d.ts

@@ -1,4 +1,4 @@
-import type { Campaign, CampaignParameters } from "@sdk";
+import { type Campaign, type CampaignParameters } from "@sdk";
 import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
 import { type tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1.js

@@ -1,4 +1,5 @@
 import { decodeCall } from "../../../../utils/decodeCalls";
+import { ChainId } from "@sdk";
 import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
 import { tokenType } from "./helpers/tokenType";
 import { processorMapping } from "./processor/processorMapping";
@@ -190,7 +191,7 @@ function parseForBalancer(calls, index, targetToken, name) {
 function parseForStaking(campaign, calls, index, targetToken) {
     try {
         const whitelist = campaign.campaignParameters.whitelist;
-        if (whitelist.length === 1 && campaign.chainId !== 42161) {
+        if (whitelist.length === 1 && campaign.chainId !== ChainId.ARBITRUM) {
             const forwarders = campaign.campaignParameters.forwarders;
             if (forwarders.length === 1) {
                 if (forwarders[0].sender === whitelist[0]) {

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

@@ -101,6 +101,8 @@ export class CampaignRepository {
         }
     }
     static async upsertMany(campaigns) {
+        if (!campaigns.length)
+            return { success: 0, fail: 0 };
         const campaignType = CampaignService.getTypeFromV3(campaigns[0].type);
         const data = [];
         for (const campaign of campaigns) {

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

@@ -15,7 +15,7 @@ export class CampaignService {
     }
     static async create(campaign) {
         const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
-        await OpportunityService.createFromCampaign(campaign);
+        await OpportunityService.createFromCampaign(campaign); // TODO REMOVE TRUE
         return await CampaignRepository.upsert({ id, ...campaign });
     }
     static async createMany(campaigns) {
@@ -25,7 +25,7 @@ export class CampaignService {
             const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
             campaign.computeChainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
             try {
-                await OpportunityService.createFromCampaign(campaign);
+                await OpportunityService.createFromCampaign(campaign, true); // TODO REMOVE TRUE
                 campaignsToInsert.push({ id, ...campaign });
             }
             catch (err) {

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

@@ -37,7 +37,21 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                     authorization: string;
                 };
                 response: {
-                    200: void;
+                    200: {
+                        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;
                 };
             };
         };
@@ -522,7 +536,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            sum: File;
+                            sum: string;
                         };
                     };
                 };

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

@@ -6,7 +6,21 @@ import { type TvlRecord } from "../tvl";
 import type { CreateOpportunityModel, GetOpportunitiesQueryModel, UpdateOpportunityModel } from "./opportunity.model";
 export declare abstract class OpportunityRepository {
     #private;
-    static upsert(newOpp: CreateOpportunityModel): Promise<void>;
+    static create(newOpp: CreateOpportunityModel, upsert?: boolean): Promise<{
+        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 findUnique(id: string): Promise<({
         Chain: {
             name: string;
@@ -886,7 +900,7 @@ export declare abstract class OpportunityRepository {
         dailyRewards: number;
     }>;
     static aggregateSum(field: keyof Prisma.OpportunitySumAggregateInputType, query: GetOpportunitiesQueryModel): Promise<{
-        sum: never;
+        sum: string;
     }>;
     static update(id: string, data: UpdateOpportunityModel): Promise<{
         name: string;

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

@@ -2,6 +2,7 @@ import { apiDbClient } from "../../../utils/prisma";
 import { Status } from "../../../../database/api/.generated";
 import moment from "moment";
 import { AprService } from "../apr";
+import { ProtocolService } from "../protocol";
 import { RewardService } from "../reward";
 import { TvlService } from "../tvl";
 export class OpportunityRepository {
@@ -38,7 +39,29 @@ export class OpportunityRepository {
             },
         };
     }
-    static async upsert(newOpp) {
+    static async create(newOpp, upsert = false) {
+        if (!!newOpp.mainProtocol) {
+            let mainProtocol = await apiDbClient.protocol.findUnique({ where: { id: newOpp.mainProtocol } });
+            if (!mainProtocol) {
+                mainProtocol = await ProtocolService.create({
+                    id: newOpp.mainProtocol,
+                    name: newOpp.mainProtocol,
+                    tags: [newOpp.action],
+                    url: "",
+                    icon: "",
+                    description: "",
+                });
+            }
+            // Override action with the protocol's action if it differs
+            if (mainProtocol.tags.includes("AMM"))
+                newOpp.action = "POOL";
+            if (mainProtocol.tags.includes("DEX"))
+                newOpp.action = "POOL";
+            if (mainProtocol.tags.includes("LENDING"))
+                newOpp.action = "BORROW";
+            if (mainProtocol.tags.includes("LENDING") && !!newOpp.name && newOpp.name.includes("Supply"))
+                newOpp.action = "LEND";
+        }
         const data = {
             id: newOpp.id,
             action: newOpp.action,
@@ -47,7 +70,7 @@ export class OpportunityRepository {
             status: newOpp.status,
             type: newOpp.type,
             Chain: { connect: { id: newOpp.chainId } },
-            MainProtocol: { connect: { id: newOpp.mainProtocol } },
+            MainProtocol: !!newOpp.mainProtocol ? { connect: { id: newOpp.mainProtocol } } : undefined,
             Protocols: {
                 connect: (newOpp.protocols ?? []).map((protocol) => {
                     return { id: protocol };
@@ -64,11 +87,21 @@ export class OpportunityRepository {
                 }),
             },
         };
-        await apiDbClient.opportunity.upsert({
-            where: { id: newOpp.id },
-            create: data,
-            update: data,
-        });
+        if (upsert) {
+            await apiDbClient.opportunity.upsert({
+                where: { id: newOpp.id },
+                create: data,
+                update: data,
+            });
+        }
+        else {
+            const opportunity = await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });
+            if (!!opportunity) {
+                return opportunity;
+            }
+            await apiDbClient.opportunity.create({ data });
+        }
+        return await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });
     }
     static async findUnique(id) {
         return await apiDbClient.opportunity.findUnique({

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

@@ -10,8 +10,22 @@ export declare abstract class OpportunityService {
      * @param newOpp the new opportunity to create
      * @returns {Promise<Opportunity|undefined>}
      */
-    static create(newOpp: Omit<CreateOpportunityModel, "id">): Promise<void>;
-    static createFromCampaign(campaign: Omit<CreateCampaignModel, "id">): Promise<{
+    static create(newOpp: Omit<CreateOpportunityModel, "id">): Promise<{
+        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 createFromCampaign(campaign: Omit<CreateCampaignModel, "id">, upsert?: boolean): Promise<{
         id: string;
         chainId: number;
         type: import("../../../../database/api/.generated").$Enums.CampaignType;
@@ -440,7 +454,7 @@ export declare abstract class OpportunityService {
         dailyRewards: number;
     };
     static aggregate(query: GetOpportunitiesQueryModel, field: keyof Prisma.OpportunitySumAggregateInputType): Promise<{
-        sum: never;
+        sum: string;
     }>;
     static update(id: string, data: UpdateOpportunityModel): Promise<{
         name: string;

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

@@ -32,9 +32,9 @@ export class OpportunityService {
      */
     static async create(newOpp) {
         const id = OpportunityService.hashId(newOpp);
-        return await OpportunityRepository.upsert({ ...newOpp, id });
+        return await OpportunityRepository.create({ ...newOpp, id });
     }
-    static async createFromCampaign(campaign) {
+    static async createFromCampaign(campaign, upsert = false) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
         const metadata = await OpportunityService.getMetadata(campaign);
         metadata.tags = [...((await UserService.findUnique(campaign.creator))?.tags ?? []), ...(campaign?.tags ?? [])];
@@ -62,7 +62,7 @@ export class OpportunityService {
             depositUrl: !!params.url ? params.url : undefined,
             tags: metadata.tags,
         };
-        await OpportunityRepository.upsert(opportunity);
+        await OpportunityRepository.create(opportunity, upsert);
         return opportunity;
     }
     /**
@@ -78,6 +78,7 @@ export class OpportunityService {
             ...firstCampaign,
             type: campaignTypeToEnumMap[firstCampaign.type],
             chainId: firstCampaign.distributionChainId,
+            computeChainId: firstCampaign.computeChainId,
             creator: firstCampaign.creatorAddress,
             rewardTokenAddress: firstCampaign.RewardToken.address,
             opportunityIdentifier: opportunity.identifier,
@@ -85,7 +86,8 @@ export class OpportunityService {
             params: JSON.stringify(firstCampaign.params),
             startTimestamp: firstCampaign.startTimestamp.toString(),
             endTimestamp: firstCampaign.endTimestamp.toString(),
-        });
+        }, true // Upserting
+        );
     }
     /**
      * build/fetch metadata of a campaign's opportunity
@@ -100,7 +102,8 @@ export class OpportunityService {
             case "CLAMM":
                 return getClammMetadata(chainId, campaignParams);
             case "ERC20":
-                return getErc20Metadata(chainId, campaign.campaignId, campaign.rewardTokenAddress, campaign.amount, campaignParams);
+                return getErc20Metadata(chainId, campaign.chainId, // distributionChainId
+                campaign.campaignId, campaign.rewardTokenAddress, campaign.amount, campaignParams);
             case "ERC20_SNAPSHOT":
                 return getErc20SnapshotMetadata(chainId, campaignParams);
             case "JSON_AIRDROP":

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

@@ -1,3 +1,3 @@
 import type { OpportunityMetadata } from "..";
 import type { ChainId, ERC20Campaign } from "@sdk";
-export declare const getErc20Metadata: (chainId: ChainId, campaignId: string, rewardToken: string, amount: string, params: ERC20Campaign["campaignParameters"]) => Promise<OpportunityMetadata>;
+export declare const getErc20Metadata: (computeChainId: ChainId, distributionChainId: ChainId, campaignId: string, rewardToken: string, amount: string, params: ERC20Campaign["campaignParameters"]) => Promise<OpportunityMetadata>;

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

@@ -2,17 +2,19 @@ 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) => {
+export const getErc20Metadata = async (computeChainId, distributionChainId, campaignId, rewardToken, amount, params) => {
     let action = "HOLD";
     let name = `Hold ${params.symbolTargetToken}`;
     let mainProtocolId = undefined;
-    const tokens = [{ chainId, address: params.targetToken }];
+    const tokens = [{ chainId: computeChainId, address: params.targetToken }];
     try {
-        const [dynamicData] = await CampaignService.fetchDynamicData(chainId, CampaignType.ERC20, [
+        const [dynamicData] = await CampaignService.fetchDynamicData(computeChainId, CampaignType.ERC20, [
             {
                 campaignId,
                 rewardToken,
                 amount,
+                chainId: distributionChainId,
+                computeChainId,
                 campaignParameters: params,
             },
         ]);
@@ -20,37 +22,36 @@ export const getErc20Metadata = async (chainId, campaignId, rewardToken, amount,
         name = dynamicData?.typeInfo?.cardName;
         mainProtocolId = dynamicData?.typeInfo?.protocol?.toLowerCase().replace(" ", "");
         const protocol = (await ProtocolService.findMany({ id: mainProtocolId }))?.[0];
-        if (!protocol) {
-            mainProtocolId = undefined;
+        if (!!protocol) {
+            mainProtocolId = protocol?.id;
         }
-        mainProtocolId = protocol?.id;
         // Case of lending protocols and receipt tokens
         if (!!dynamicData && !!dynamicData.typeInfo?.underlying) {
-            tokens.push({ chainId, address: 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, address: dynamicData.typeInfo.shortToken });
-            tokens.push({ chainId, address: 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, address: dynamicData.typeInfo.tokenA });
-            tokens.push({ chainId, address: 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, address: dynamicData.typeInfo.token0 });
-            tokens.push({ chainId, address: 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, address: dynamicData.typeInfo.token0Address });
-            tokens.push({ chainId, address: dynamicData.typeInfo.token1Address });
-            tokens.push({ chainId, address: 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 {

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

@@ -46,7 +46,21 @@ export declare const v4: Elysia<"/v4", false, {
                         authorization: string;
                     };
                     response: {
-                        200: void;
+                        200: {
+                            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;
                     };
                 };
             };
@@ -531,7 +545,7 @@ export declare const v4: Elysia<"/v4", false, {
                         headers: unknown;
                         response: {
                             200: {
-                                sum: File;
+                                sum: string;
                             };
                         };
                     };

package/dist/src/utils/generateCardName.js

@@ -14,22 +14,22 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
         case tokenType.ra:
         case tokenType.syncswap:
         case tokenType.pancakeswap:
-            return `${typeInfo.protocol} ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+            return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
         case tokenType.pendleYT:
             return `Hold ${typeInfo.protocol} ${typeInfo.name}`;
         case tokenType.pendle:
             return `Provide ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
         case tokenType.balancerGauge:
-            return `${typeInfo.protocol} ${symbols.join("/")}`;
+            return `${typeInfo.protocol} ${symbols.join("-")}`;
         case tokenType.balancerPool: {
-            let cardName = `${typeInfo.protocol} ${symbols.join("/")}`;
+            let cardName = `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
             if (typeInfo.vault === "0xFB43069f6d0473B85686a85F4Ce4Fc1FD8F00875") {
-                cardName = `Jellyverse Pool ${symbols.join("/")}`;
+                cardName = `Provide liquidity to Jellyverse Pool ${symbols.join("-")}`;
             }
             return cardName;
         }
         case tokenType.aura:
-            return `${typeInfo.protocol} ${symbols.join("/")}`;
+            return `Provide liquidity to ${typeInfo.protocol} ${symbols.join("-")}`;
         case tokenType.gearbox:
             return `${typeInfo.protocol} ${typeInfo.symbolUnderlyingToken} Deposit`;
         case tokenType.compound:
@@ -42,7 +42,7 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
             return `Lend ${cardToken} on ${typeInfo.protocol}`;
         }
         case tokenType.rfx:
-            return `Supply ${typeInfo.symbolShortToken}/${typeInfo.symbolLongToken} on ${typeInfo.protocol}`;
+            return `Supply ${typeInfo.symbolShortToken}-${typeInfo.symbolLongToken} on ${typeInfo.protocol}`;
         case tokenType.radiant_borrow:
         case tokenType.aave_borrowing:
         case tokenType.yei_borrowing:
@@ -71,7 +71,7 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
             return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol} ${typeInfo.symbolCollateral} Silo`;
         case tokenType.curve:
         case tokenType.curve_2:
-            return `${typeInfo.protocol} ${Object.values(typeInfo.poolTokens).join("/")}`;
+            return `Provide liquidity to ${typeInfo.protocol} ${Object.values(typeInfo.poolTokens).join("-")}`;
         case tokenType.fluid:
             return `Lend ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
         case tokenType.enzyme:
@@ -81,7 +81,7 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
         case tokenType.silostaking:
             return `Stake ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
         case tokenType.beefy:
-            return `${typeInfo.protocol} ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+            return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
         case tokenType.toros:
             return `${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) on ${typeInfo.protocol}`;
         case tokenType.ironcladStaking:
@@ -91,18 +91,18 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
         case tokenType.maverickBoostedPosition:
             return `Maverick Boosted Position ${campaign.campaignParameters.symbolTargetToken}`;
         case tokenType.zkSwapThreePool:
-            return `${typeInfo.protocol} ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}/${typeInfo.symbolToken2}`;
+            return `Provide liquidity to ${typeInfo.protocol} ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}-${typeInfo.symbolToken2}`;
         case tokenType.maha:
-            return `Stake ${typeInfo.symbolToken0}/${typeInfo.symbolToken1} LP on ${typeInfo.protocol}`;
+            return `Stake ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} LP on ${typeInfo.protocol}`;
         case tokenType.tempest:
         case tokenType.tempestStaking:
-            return `Deposit into ${typeInfo.symbolToken0}/${typeInfo.symbolToken1} vault on ${typeInfo.protocol}`;
+            return `Deposit into ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} vault on ${typeInfo.protocol}`;
         case tokenType.holdstation:
             return `Hold vault token ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.protocol}`;
         case tokenType.staking:
             return `${typeInfo.lockNFT !== undefined ? "Lock" : "Stake"} ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.stakingSymbol}`;
         case tokenType.cpmmGamma:
-            return `Provide ${typeInfo.symbolToken0}/${typeInfo.symbolToken1} on ${typeInfo.protocol}`;
+            return `Provide ${typeInfo.symbolToken0}-${typeInfo.symbolToken1} on ${typeInfo.protocol}`;
         case tokenType.crosscurve:
             if (typeInfo.name.toLowerCase() === "eywa/usdt") {
                 return `Curve ${typeInfo.name}`;