@merkl/api 0.20.84 → 0.20.86

package/dist/src/engine/dynamicData/factory.js

@@ -6,6 +6,8 @@ import { ClammDynamicData } from "./implementations/Clamm";
 import { CompoundDynamicData } from "./implementations/Compound";
 import { CompoundV3DynamicData } from "./implementations/CompoundV3";
 import { DolomiteDynamicData } from "./implementations/Dolomite";
+import { ERC721DynamicData } from "./implementations/ERC721";
+import { ERCMultiTokenDynamicData } from "./implementations/ERCMultiToken";
 import { EigenLayerDynamicData } from "./implementations/EigenLayer";
 import { EncompassingDynamicData } from "./implementations/Encompassing";
 import { Erc20DynamicData } from "./implementations/Erc20";
@@ -54,11 +56,11 @@ const map = {
     [Campaign.MORPHOSUPPLY]: new DefaultDynamicData(), // TODO
     [Campaign.SYNCSWAP_VAULT]: new DefaultDynamicData(), // TODO
     [Campaign.MAVERICK_BP]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC6909]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC6909FIXAPR]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC1155]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC1155FIXAPR]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC721]: new DefaultDynamicData(), // TODO
-    [Campaign.ERC721FIXAPR]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC6909]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC6909FIXAPR]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC1155]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC1155FIXAPR]: new ERCMultiTokenDynamicData(),
+    [Campaign.ERC721]: new ERC721DynamicData(),
+    [Campaign.ERC721FIXAPR]: new ERC721DynamicData(),
 };
 export const dynamicDataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/dynamicData/implementations/ERC721.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.ERC721 | Campaign.ERC721FIXAPR;
+export declare class ERC721DynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<ERC721CampaignDynamicData[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/ERC721.js

@@ -0,0 +1,85 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { AragornEscrowInterface, BN2Number, ChainInteractionService, ERC20Interface, YEAR, } from "@sdk";
+import { ERC721SubCampaignType } from "libs/sdk/src/types/merkl/campaignTypes/erc721";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { getFixedApr, hasFixedAprConfig } from "../utils/getFixedApr";
+export class ERC721DynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const campaign of campaigns) {
+            if (campaign.campaignSubType === ERC721SubCampaignType.VOTING_POWER) {
+                calls.push({
+                    allowFailure: true,
+                    callData: AragornEscrowInterface.encodeFunctionData("totalLocked"),
+                    target: campaign.campaignParameters.extraContracts[0],
+                });
+            }
+            else {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("totalSupply"), // TODO do not fit global interface
+                    target: campaign.campaignParameters.targetToken,
+                });
+            }
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            let symbolToken = campaign.campaignParameters.symbolTargetToken;
+            let token = campaign.campaignParameters.targetToken;
+            if (campaign.campaignSubType === ERC721SubCampaignType.VOTING_POWER) {
+                symbolToken = campaign.campaignParameters.symbolUnderlyingToken;
+                token = campaign.campaignParameters.extraContracts[1];
+                try {
+                    totalSupply = BN2Number(AragornEscrowInterface.decodeFunctionResult("totalLocked", result[i].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+                }
+                catch {
+                    log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                    totalSupply = 0.0000001;
+                }
+            }
+            else {
+                try {
+                    totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+                }
+                catch {
+                    log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                    totalSupply = 0.0000001;
+                }
+            }
+            i++;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const priceTargetToken = (await pricer.get({
+                address: token,
+                chainId: campaign.computeChainId,
+                // Remove the `c` at the beginning of the symbol and the `v3` at the end
+                symbol: symbolToken,
+            })) ?? 0;
+            let apr = (priceRewardToken * BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) * YEAR * 100) /
+                campaign.campaignParameters.duration /
+                (totalSupply * priceTargetToken);
+            const rewardTokens = await TokenService.findManyOrCreate([
+                { chainId: campaign.chainId, address: campaign.rewardToken },
+            ]);
+            const rewardToken = rewardTokens[0];
+            if (rewardToken.isPoint) {
+                apr = apr / 365 / 100;
+            }
+            else if (hasFixedAprConfig(campaign.campaignParameters)) {
+                apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
+            }
+            dynamicData.push({
+                ...campaign,
+                apr,
+                totalSupplyTargetToken: totalSupply,
+                tvl: totalSupply * priceTargetToken,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/implementations/ERCMultiToken.d.ts

@@ -0,0 +1,7 @@
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { DynamicDataBuilder } from "../interface";
+type campaignType = Campaign.ERC6909 | Campaign.ERC6909FIXAPR | Campaign.ERC1155 | Campaign.ERC1155FIXAPR;
+export declare class ERCMultiTokenDynamicData implements DynamicDataBuilder<campaignType> {
+    build(chainId: MerklChainId, campaigns: CampaignParameters<campaignType>[]): Promise<ERC6909CampaignDynamicData[]>;
+}
+export {};

package/dist/src/engine/dynamicData/implementations/ERCMultiToken.js

@@ -0,0 +1,159 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { BN2Number, ChainInteractionService, CloberBookManagerInterface, CloberPoolInterface, ERC20Interface, ERC6909Interface, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { getFixedApr, hasFixedAprConfig } from "../utils/getFixedApr";
+export class ERCMultiTokenDynamicData {
+    async build(chainId, campaigns) {
+        const pricer = await Pricer.load();
+        const calls = [];
+        for (const campaign of campaigns) {
+            calls.push({
+                allowFailure: true,
+                callData: ERC6909Interface.encodeFunctionData("totalSupply", [campaign.campaignParameters.tokenId]),
+                target: campaign.campaignParameters.targetToken,
+            });
+            calls.push({
+                allowFailure: true,
+                callData: CloberPoolInterface.encodeFunctionData("bookManager"),
+                target: campaign.campaignParameters.targetToken,
+            });
+            calls.push({
+                allowFailure: true,
+                callData: CloberPoolInterface.encodeFunctionData("getBookPairs", [campaign.campaignParameters.tokenId]),
+                target: campaign.campaignParameters.targetToken,
+            });
+            calls.push({
+                allowFailure: true,
+                callData: CloberPoolInterface.encodeFunctionData("getLiquidity", [campaign.campaignParameters.tokenId]),
+                target: campaign.campaignParameters.targetToken,
+            });
+        }
+        const result = await ChainInteractionService(chainId).fetchState(calls);
+        let i = 0;
+        const dynamicData = [];
+        for (const campaign of campaigns) {
+            let totalSupply;
+            let tvl;
+            let priceTargetToken;
+            try {
+                totalSupply = BN2Number(ERC6909Interface.decodeFunctionResult("totalSupply", result[i].returnData)[0], campaign.campaignParameters.decimalsTargetToken);
+            }
+            catch {
+                log.warn(`Error getting totalSupply for campaign ${campaign.campaignId} and token ${campaign.campaignParameters.targetToken}`);
+                totalSupply = 0.0000001;
+            }
+            i++;
+            // Specific to Clober so far
+            try {
+                const bookManager = CloberPoolInterface.decodeFunctionResult("bookManager", result[i + 1].returnData)[0];
+                const bookPairs = CloberPoolInterface.decodeFunctionResult("getBookPairs", result[i + 2].returnData);
+                const liquidity = CloberPoolInterface.decodeFunctionResult("getLiquidity", result[i + 3].returnData);
+                const liquidityToken0 = BigInt(liquidity[0].reserve) + BigInt(liquidity[0].cancelable) + BigInt(liquidity[0].claimable);
+                const liquidityToken1 = BigInt(liquidity[1].reserve) + BigInt(liquidity[1].cancelable) + BigInt(liquidity[1].claimable);
+                const bookPair0 = bookPairs[0] < bookPairs[1] ? bookPairs[0] : bookPairs[1];
+                const bookPair1 = bookPairs[0] < bookPairs[1] ? bookPairs[1] : bookPairs[0];
+                let token0;
+                let token1;
+                let symbol0;
+                let symbol1;
+                let decimals0;
+                let decimals1;
+                {
+                    const bookManagerCalls = [
+                        {
+                            allowFailure: true,
+                            callData: CloberBookManagerInterface.encodeFunctionData("getBookKey", [bookPair0]),
+                            target: bookManager,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: CloberBookManagerInterface.encodeFunctionData("getBookKey", [bookPair1]),
+                            target: bookManager,
+                        },
+                    ];
+                    const resultBookManager = await ChainInteractionService(chainId).fetchState(bookManagerCalls);
+                    let j = 0;
+                    const bookKey0 = CloberBookManagerInterface.decodeFunctionResult("getBookKey", resultBookManager[j++].returnData)[0];
+                    const bookKey1 = CloberBookManagerInterface.decodeFunctionResult("getBookKey", resultBookManager[j++].returnData)[0];
+                    token0 = bookKey0[0];
+                    token1 = bookKey1[0];
+                }
+                {
+                    const tokenCalls = [
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: token0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("symbol"),
+                            target: token1,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: token0,
+                        },
+                        {
+                            allowFailure: true,
+                            callData: ERC20Interface.encodeFunctionData("decimals"),
+                            target: token1,
+                        },
+                    ];
+                    const resultTokens = await ChainInteractionService(chainId).fetchState(tokenCalls);
+                    let j = 0;
+                    symbol0 = ERC20Interface.decodeFunctionResult("symbol", resultTokens[j++].returnData)[0];
+                    symbol1 = ERC20Interface.decodeFunctionResult("symbol", resultTokens[j++].returnData)[0];
+                    decimals0 = ERC20Interface.decodeFunctionResult("decimals", resultTokens[j++].returnData)[0];
+                    decimals1 = ERC20Interface.decodeFunctionResult("decimals", resultTokens[j++].returnData)[0];
+                }
+                const priceToken0 = (await pricer.get({
+                    address: token0,
+                    chainId: campaign.computeChainId,
+                    symbol: symbol0,
+                })) ?? 0;
+                const priceToken1 = (await pricer.get({
+                    address: token1,
+                    chainId: campaign.computeChainId,
+                    symbol: symbol1,
+                })) ?? 0;
+                tvl = priceToken0 * BN2Number(liquidityToken0, decimals0) + priceToken1 * BN2Number(liquidityToken1, decimals1);
+                priceTargetToken = tvl / totalSupply;
+            }
+            catch {
+                priceTargetToken =
+                    (await pricer.get({
+                        address: campaign.campaignParameters.targetToken,
+                        chainId: campaign.computeChainId,
+                        symbol: campaign.campaignParameters.symbolTargetToken,
+                    })) ?? 0;
+                tvl = totalSupply * priceTargetToken;
+            }
+            i += 4;
+            const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
+            const rewardTokens = await TokenService.findManyOrCreate([
+                { chainId: campaign.chainId, address: campaign.rewardToken },
+            ]);
+            const rewardToken = rewardTokens[0];
+            let apr = (priceRewardToken * BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) * YEAR * 100) /
+                campaign.campaignParameters.duration /
+                tvl;
+            if (rewardToken.isPoint) {
+                apr = apr / 365 / 100;
+            }
+            else if (hasFixedAprConfig(campaign.campaignParameters)) {
+                apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
+            }
+            dynamicData.push({
+                ...campaign,
+                apr,
+                totalSupplyTargetToken: totalSupply,
+                tvl,
+                priceRewardToken: priceRewardToken,
+            });
+        }
+        return dynamicData;
+    }
+}

package/dist/src/engine/dynamicData/utils/getFixedApr.d.ts

@@ -4,6 +4,6 @@ export type BaseFixAPRConfig = {
     targetTokenPricing: boolean;
     rewardTokenPricing: boolean;
 };
-export type FixedAprCampaignType = Campaign.ERC20_FIX_APR | Campaign.HYPERDRIVELOGFIXPROCESSOR;
+export type FixedAprCampaignType = Campaign.ERC20_FIX_APR | Campaign.HYPERDRIVELOGFIXPROCESSOR | Campaign.ERC6909FIXAPR | Campaign.ERC1155FIXAPR | Campaign.ERC721FIXAPR;
 export declare function hasFixedAprConfig<T>(params: T): params is T & BaseFixAPRConfig;
 export declare function getFixedApr(campaignParameters: CampaignParameters<FixedAprCampaignType>, priceRewardToken: number, priceTargetToken: number): number;

package/dist/src/engine/erc20SubTypeProcessors/helpers/ownerFinder.js

@@ -3,6 +3,7 @@ const ownerAddresses = {
     "0xbF7E49483881C76487b0989CD7d9A8239B20CA41": tokenType.curve_2,
     "0x42a856dbEBB97AbC1269EAB32f3bb40C15102819": tokenType.satlayer,
     "0x4C911bf7A008C497719CBEb1a376f1cEc9e2c1d6": tokenType.hanji_liquidity_vault_token,
+    "0x6e9d701fB6478Ed5972a37886C2BA6C82a4cBb4C": tokenType.gamma, // Gamma Bob owner
 };
 export function getTypeFromOwnerAddress(address) {
     if (ownerAddresses[address]) {

package/dist/src/engine/erc20SubTypeProcessors/helpers/tokenType.d.ts

@@ -99,7 +99,8 @@ export declare enum tokenType {
     beraborrow_gauge = "beraborrow_gauge",
     curve_gauge = "curve_gauge",
     sake_borrowing = "sake_borrowing",
-    sake_lending = "sake_lending"
+    sake_lending = "sake_lending",
+    gamma = "gamma"
 }
 export declare const tokenTypeToProtocolAndAction: Record<tokenType, {
     protocol: ProtocolId | undefined;

package/dist/src/engine/erc20SubTypeProcessors/helpers/tokenType.js

@@ -100,6 +100,7 @@ export var tokenType;
     tokenType["curve_gauge"] = "curve_gauge";
     tokenType["sake_borrowing"] = "sake_borrowing";
     tokenType["sake_lending"] = "sake_lending";
+    tokenType["gamma"] = "gamma";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocolAndAction = {
     [tokenType.aave_borrowing]: { protocol: "aave", action: OpportunityAction.BORROW },
@@ -224,4 +225,8 @@ export const tokenTypeToProtocolAndAction = {
         protocol: "sake",
         action: OpportunityAction.LEND,
     },
+    [tokenType.gamma]: {
+        protocol: "gamma",
+        action: OpportunityAction.POOL,
+    },
 };

package/dist/src/engine/erc20SubTypeProcessors/implementations/GammaALMProcessor.d.ts

@@ -0,0 +1,30 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawGamma;
+    call: string;
+    target: keyof callKeysGamma;
+    metaData?: any;
+};
+type callKeysGamma = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+};
+type dataRawGamma = callKeysGamma & {
+    underlyingProtocol: string;
+};
+type dataTypeGamma = dataType & {
+    tokenPrice: string;
+};
+export declare class GammaALMProcessor extends GenericProcessor<callKeysGamma, dataRawGamma, dataTypeGamma> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeGamma>;
+}
+export {};

package/dist/src/engine/erc20SubTypeProcessors/implementations/GammaALMProcessor.js

@@ -0,0 +1,52 @@
+import { generateCardName } from "@/utils/generateCardName";
+import { withTimeout } from "@sdk";
+import axios from "axios";
+import { GenericProcessor } from "../GenericProcessor";
+async function getVaultInfo(targetVaultAddress, chainId) {
+    let data = [];
+    try {
+        data = await withTimeout((async () => {
+            data = (await axios.get(`https://api.gamma.xyz/frontend/hypervisors/allDataSummary?chain=${chainId}`))
+                .data;
+            return data;
+        })(), 5000);
+    }
+    catch (e) {
+        return null;
+    }
+    for (const item of data) {
+        if (item.address.toLowerCase() === targetVaultAddress.toLowerCase()) {
+            return {
+                tvl: Number(item.tvlUSD),
+                protocol: item.protocol,
+            };
+        }
+    }
+    return null;
+}
+export class GammaALMProcessor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    async processingRound5(_index, type, typeInfo, _calls, campaign, _pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const vaultInfo = await getVaultInfo(campaign.campaignParameters.targetToken, campaign.computeChainId);
+        const tvl = !!vaultInfo ? vaultInfo.tvl : 0;
+        const protocol = !!vaultInfo ? vaultInfo.protocol : "";
+        const priceTargetToken = tvl / totalSupply;
+        typeInfo.underlyingProtocol = protocol;
+        return {
+            ...typeInfo,
+            totalSupply,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign),
+            tokensDisplay: [{ symbol: campaign.campaignParameters.symbolTargetToken, address: typeInfo.tokenAddress }],
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/implementations/processorMapping.js

@@ -18,6 +18,7 @@ import { EulerBorrowProcessor } from "./EulerBorrowProcessor";
 import { EulerLendProcessor } from "./EulerLendProcessor";
 import { FluidProcessor } from "./FluidProcessor";
 import { FraxProcessor } from "./FraxProcessor";
+import { GammaALMProcessor } from "./GammaALMProcessor";
 import { GammaProcessor } from "./GammaProcessor";
 import { GearboxProcessor } from "./GearboxProcessor";
 import { HanjiVaultProcessor } from "./HanjiVaultProcessor";
@@ -144,4 +145,5 @@ export const processorMapping = {
     [tokenType.curve_gauge]: StakedCurveProcessor,
     [tokenType.sake_borrowing]: AaveProcessor,
     [tokenType.sake_lending]: AaveProcessor,
+    [tokenType.gamma]: GammaALMProcessor,
 };

package/dist/src/engine/opportunityMetadata/factory.js

@@ -7,6 +7,8 @@ import { CompoundMetadata } from "./implementations/Compound";
 import { CompoundV3Metadata } from "./implementations/CompoundV3";
 import { DefaultMetadata } from "./implementations/Default";
 import { DolomiteMetadata } from "./implementations/Dolomite";
+import { ERC721Metadata } from "./implementations/ERC721";
+import { ERCMultiTokenMetadata } from "./implementations/ERCMultiToken";
 import { EigenLayerMetadata } from "./implementations/EigenLayer";
 import { EncompassingMetadata } from "./implementations/Encompassing";
 import { Erc20Metadata } from "./implementations/Erc20";
@@ -57,11 +59,11 @@ const map = {
     [Campaign.EVENT_BASED]: new EventBasedMetadata(),
     [Campaign.ERC20REBASEFIXAPR]: new Erc20Metadata(),
     [Campaign.MAVERICK_BP]: new DefaultMetadata(), // TODO
-    [Campaign.ERC6909]: new DefaultMetadata(), // TODO
-    [Campaign.ERC6909FIXAPR]: new DefaultMetadata(), // TODO
-    [Campaign.ERC1155]: new DefaultMetadata(), // TODO
-    [Campaign.ERC1155FIXAPR]: new DefaultMetadata(), // TODO
-    [Campaign.ERC721]: new DefaultMetadata(), // TODO
-    [Campaign.ERC721FIXAPR]: new DefaultMetadata(), // TODO
+    [Campaign.ERC6909]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC6909FIXAPR]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC1155]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC1155FIXAPR]: new ERCMultiTokenMetadata(),
+    [Campaign.ERC721]: new ERC721Metadata(),
+    [Campaign.ERC721FIXAPR]: new ERC721Metadata(),
 };
 export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/opportunityMetadata/implementations/ERC721.d.ts

@@ -0,0 +1,16 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC721 | CampaignEnum.ERC721FIXAPR;
+export declare class ERC721Metadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: undefined;
+        depositUrl: undefined;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/ERC721.js

@@ -0,0 +1,12 @@
+import { OpportunityAction } from "@db/api";
+export class ERC721Metadata {
+    async build(computeChainId, params) {
+        return {
+            action: OpportunityAction.HOLD,
+            name: `Hold ${params.symbolTargetToken}`,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: undefined,
+            depositUrl: undefined,
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/implementations/ERCMultiToken.d.ts

@@ -0,0 +1,16 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.ERC1155 | CampaignEnum.ERC1155FIXAPR | CampaignEnum.ERC6909 | CampaignEnum.ERC6909FIXAPR;
+export declare class ERCMultiTokenMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
+        action: "HOLD";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: undefined;
+        depositUrl: undefined;
+    }>;
+}
+export {};

package/dist/src/engine/opportunityMetadata/implementations/ERCMultiToken.js

@@ -0,0 +1,12 @@
+import { OpportunityAction } from "@db/api";
+export class ERCMultiTokenMetadata {
+    async build(computeChainId, params) {
+        return {
+            action: OpportunityAction.HOLD,
+            name: `Hold ${params.symbolTargetToken} with token ID ${params.tokenId}`,
+            tokens: [{ chainId: computeChainId, address: params.targetToken }],
+            mainProtocol: undefined,
+            depositUrl: undefined,
+        };
+    }
+}

package/dist/src/utils/generateCardName.js

@@ -184,6 +184,8 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
             return "Provide Liquidity on Hanji Vault";
         case tokenType.bunniV2:
             return `Provide Liquidity on Bunni V2 ${typeInfo.symbolToken0}-${typeInfo.symbolToken1}`;
+        case tokenType.gamma:
+            return `Provide liquidity to Gamma ${capitalize(typeInfo.protocol)} ${campaign.campaignParameters.symbolTargetToken} vault`;
         default:
             // OVERRIDE
             switch (typeInfo.tokenAddress) {