@merkl/api 0.21.47 → 1.0.0

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

@@ -1,91 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { providers } from "@/utils/providers";
-import { TvlType } from "@db/api";
-import { AjnaSubCampaignType, BN2Number, ChainInteractionService, ERC20Pool__factory, NETWORK_LABELS, PoolInfoUtilsInterface, } from "@sdk";
-import { POOL_INFO_UTILS } from "@sdk";
-import axios from "axios";
-export class AjnaTVLBuilder {
-    async build(computeChainId, campaigns) {
-        const calls = [];
-        for (const campaign of campaigns) {
-            if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
-                calls.push({
-                    allowFailure: true,
-                    callData: PoolInfoUtilsInterface.encodeFunctionData("poolPricesInfo", [campaign.campaignParameters.poolId]),
-                    target: POOL_INFO_UTILS[campaign.computeChainId],
-                });
-            }
-        }
-        const result = await ChainInteractionService(computeChainId).fetchState(calls);
-        let index = 0;
-        const tvls = [];
-        for (const campaign of campaigns) {
-            const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[computeChainId].toLowerCase()}/pools/${campaign.campaignParameters.poolId.toLowerCase()}`);
-            let totalSupplyTargetToken = 0;
-            let totalComputedTargetToken = 0;
-            if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
-                totalSupplyTargetToken = res?.data.results?.quote_token_balance;
-                const htpIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", result[index].returnData)[3];
-                const lupIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", result[index].returnData)[5];
-                const threshold = BN2Number(lupIndex, 0) === 0 ? lupIndex : lupIndex.gt(htpIndex) ? lupIndex.add(22) : htpIndex.add(22);
-                const InterestEarningSupplyRes = await ERC20Pool__factory.connect(campaign.campaignParameters.poolId, providers[campaign.computeChainId]).depositUpToIndex(threshold);
-                totalComputedTargetToken = BN2Number(InterestEarningSupplyRes, 18);
-                index++;
-            }
-            else
-                ;
-            totalSupplyTargetToken = res?.data.results?.debt;
-            totalComputedTargetToken =
-                campaign.campaignSubType === AjnaSubCampaignType.lend ? totalComputedTargetToken : totalSupplyTargetToken;
-            /** Handling blacklists */
-            if (campaign.campaignParameters.blacklist.length !== 0 && totalComputedTargetToken !== 0) {
-                let blacklistedSupply = 0;
-                let blacklistedPosition;
-                for (const blacklisted of campaign.campaignParameters.blacklist) {
-                    const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[computeChainId].toLowerCase()}/wallets/${blacklisted}/pools/?days_ago=1&order=-debt&p_size=50`);
-                    let nextRoute = null;
-                    if (!!res.data.next) {
-                        nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
-                    }
-                    blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
-                    blacklistedSupply = !blacklistedPosition
-                        ? 0
-                        : campaign.campaignSubType === AjnaSubCampaignType.lend
-                            ? Number(blacklistedPosition.supply)
-                            : Number(blacklistedPosition.debt);
-                    while (nextRoute !== null && blacklistedSupply !== 0) {
-                        const res = await axios.get(nextRoute);
-                        blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
-                        blacklistedSupply = !blacklistedPosition
-                            ? 0
-                            : campaign.campaignSubType === AjnaSubCampaignType.lend
-                                ? Number(blacklistedPosition.supply)
-                                : Number(blacklistedPosition.debt);
-                        if (!!res.data.next) {
-                            nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
-                        }
-                        else {
-                            nextRoute = null;
-                        }
-                    }
-                }
-                totalComputedTargetToken -= blacklistedSupply;
-            }
-            tvls.push({
-                campaign,
-                tvl: Number(res?.data.results?.tvl),
-                tvlBreakdown: [
-                    {
-                        type: TvlType.TOKEN,
-                        identifier: TokenService.hashId({
-                            chainId: computeChainId,
-                            address: campaign.rewardToken,
-                        }),
-                        value: totalComputedTargetToken,
-                    },
-                ],
-            });
-        }
-        return tvls;
-    }
-}

package/dist/src/engine/implementations/Ambient/metadata.js

@@ -1,36 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { NETWORK_LABELS, almName, } from "@sdk";
-import { getAddress } from "viem";
-export class AmbientMetadata {
-    async build(campaign) {
-        const { params, computeChainId } = campaign;
-        const platform = "Ambient";
-        let 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?.type;
-                const forwarderName = !!forwarderType ? almName(forwarderType) : null;
-                if (!!forwarderName) {
-                    whitelistNameString += ` ${forwarderName} `;
-                }
-            }
-        }
-        return {
-            name: `Provide liquidity to ${whitelistNameString} ${platform} ${params.baseToken}-${params.quoteToken}`,
-            action: OpportunityAction.POOL,
-            tokens: [
-                { chainId: computeChainId, address: params.baseToken },
-                { chainId: computeChainId, address: params.quoteToken },
-            ],
-            mainProtocol: "ambient",
-            depositUrl: AmbientMetadata.generateUrl(computeChainId, params),
-        };
-    }
-    static generateUrl(computeChainId, params) {
-        return `https://ambient.finance/trade/market/chain=0x${NETWORK_LABELS[computeChainId].toString()}&tokenA=${params.baseToken}&tokenB=${params.quoteToken}`;
-    }
-}

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

@@ -1,178 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { TvlType } from "@db/api";
-import { AmbientAddresses, AmbientLens, BN2Number, ChainInteractionService, NETWORK_LABELS, subgraphAmbientEndpoints, withRetry, } from "@sdk";
-import request, { gql } from "graphql-request";
-var AmbiantPositionType;
-(function (AmbiantPositionType) {
-    AmbiantPositionType["Concentrated"] = "concentrated";
-    AmbiantPositionType["Ambient"] = "ambient";
-    AmbiantPositionType["Knockout"] = "knockout";
-})(AmbiantPositionType || (AmbiantPositionType = {}));
-function encodeCall(chainId, holder) {
-    if (holder.positionType === AmbiantPositionType.Concentrated) {
-        return [
-            {
-                allowFailure: true,
-                callData: AmbientLens.encodeFunctionData("queryRangeTokens", [
-                    holder.owner,
-                    holder.base,
-                    holder.quote,
-                    holder.poolIdx,
-                    holder.lowerTick,
-                    holder.upperTick,
-                ]),
-                target: AmbientAddresses[chainId].CrocQuery,
-            },
-        ];
-    }
-    return [
-        {
-            allowFailure: true,
-            callData: AmbientLens.encodeFunctionData("queryAmbientTokens", [
-                holder.owner,
-                holder.base,
-                holder.quote,
-                holder.poolIdx,
-            ]),
-            target: AmbientAddresses[chainId].CrocQuery,
-        },
-    ];
-}
-async function decodeCall(result, holder) {
-    let amount0 = BigInt(0n);
-    let amount1 = BigInt(0n);
-    if (holder.positionType === AmbiantPositionType.Concentrated) {
-        const resTok = AmbientLens.decodeFunctionResult("queryRangeTokens", result);
-        amount0 = BigInt(resTok[1]);
-        amount1 = BigInt(resTok[2]);
-    }
-    if (holder.positionType === AmbiantPositionType.Ambient) {
-        const resTok = AmbientLens.decodeFunctionResult("queryAmbientTokens", result);
-        amount0 = BigInt(resTok[1]);
-        amount1 = BigInt(resTok[2]);
-    }
-    return { amount0, amount1 };
-}
-async function poolFromCampaign(campaign) {
-    return {
-        id: campaign.campaignParameters.poolId,
-        mainParameter: campaign.mainParameter, // main parameter containes info of poolAddress + AMM (in case its a priority AMM)
-        baseToken: campaign.campaignParameters.baseToken,
-        quoteToken: campaign.campaignParameters.quoteToken,
-        poolIdx: campaign.campaignParameters.poolIdx,
-        potentialHolders: await fetchAmbientPotentialPositions(campaign.campaignParameters.poolId, campaign.computeChainId),
-    };
-}
-const BATCH_NUMBER = 1000;
-const holdersQuery = gql `
-  query LiquidityChanges($poolId: String!, $minId: String!) {
-    liquidityChanges(
-      where: { pool_: { id: $poolId }, id_gt: $minId , positionType_not: "knockout"},
-      first: ${BATCH_NUMBER},
-      orderBy: pool__id
-    ) {
-      id  
-      user
-      positionType
-      bidTick
-      askTick
-      pool {
-        base
-        quote
-        poolIdx
-      }
-    }
-  }
-  `;
-async function fetchAmbientPotentialPositions(poolId, chainId) {
-    let isFullyFetched = false;
-    let holders = [];
-    let minId = "";
-    while (!isFullyFetched) {
-        const data = await withRetry(request, [
-            subgraphAmbientEndpoints[chainId],
-            holdersQuery,
-            {
-                poolId: poolId,
-                minId: minId,
-            },
-        ]);
-        const fetchedHolders = data.liquidityChanges?.map(entry => {
-            return {
-                owner: entry.user,
-                base: entry.pool.base,
-                quote: entry.pool.quote,
-                poolIdx: Number(entry.pool.poolIdx),
-                lowerTick: Number(entry.bidTick),
-                upperTick: Number(entry.askTick),
-                positionType: entry.positionType,
-            };
-        });
-        if (fetchedHolders.length < BATCH_NUMBER) {
-            isFullyFetched = true;
-        }
-        else {
-            minId = data.liquidityChanges[fetchedHolders.length - 1].id;
-        }
-        holders = holders.concat(fetchedHolders);
-    }
-    // Only keep unique positions
-    holders = Array.from(new Set(holders.map(h => JSON.stringify(h)))).map(h => JSON.parse(h));
-    return holders;
-}
-export class AmbiantTVLBuilder {
-    async build(chainId, campaigns) {
-        const tvls = [];
-        let calls = [];
-        for (const campaign of campaigns) {
-            const pool = await poolFromCampaign(campaign);
-            calls = calls.concat(...pool.potentialHolders.map(holder => encodeCall(chainId, holder)));
-        }
-        const result = await ChainInteractionService(chainId).fetchState(calls);
-        let i = 0;
-        for (const campaign of campaigns) {
-            const pool = await poolFromCampaign(campaign);
-            let baseTokenBalance = 0n;
-            let quoteTokenBalance = 0n;
-            const prevI = i;
-            try {
-                for (let index = 0; index < pool.potentialHolders.length; index++) {
-                    const res = await decodeCall(result[i++].returnData, pool.potentialHolders[index]);
-                    baseTokenBalance += BigInt(res.amount0);
-                    quoteTokenBalance += BigInt(res.amount1);
-                }
-            }
-            catch {
-                log.warn(`merklDynamic data - failed to decode state of pool ${pool.id} on ${NETWORK_LABELS[chainId]}`);
-                i = prevI + pool.potentialHolders.length;
-            }
-            const baseTokenId = TokenService.hashId({
-                chainId,
-                address: pool.baseToken,
-            });
-            const quoteTokenId = TokenService.hashId({
-                chainId,
-                address: pool.quoteToken,
-            });
-            tvls.push({
-                campaign,
-                tvl: (await TokenService.getValueByTokenId(baseTokenId, baseTokenBalance)) +
-                    (await TokenService.getValueByTokenId(quoteTokenId, quoteTokenBalance)),
-                tvlBreakdown: [
-                    {
-                        identifier: baseTokenId,
-                        type: TvlType.TOKEN,
-                        value: BN2Number(baseTokenBalance, campaign.campaignParameters.decimalsBaseToken),
-                    },
-                    {
-                        identifier: quoteTokenId,
-                        type: TvlType.TOKEN,
-                        value: BN2Number(quoteTokenBalance, campaign.campaignParameters.decimalsQuoteToken),
-                    },
-                ],
-            });
-        }
-        return tvls;
-    }
-}

package/dist/src/engine/implementations/Badger/metadata.js

@@ -1,31 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { OpportunityAction } from "@db/api";
-export class BadgerMetadata {
-    async build(campaign) {
-        const { params, computeChainId } = campaign;
-        try {
-            const [token] = await TokenService.findManyOrCreate([{ chainId: computeChainId, address: params.targetToken }]);
-            if (!token)
-                throw new Error("Failed to fetch tokens");
-            return {
-                action: OpportunityAction.BORROW,
-                name: `Borrow ${token.symbol}`,
-                tokens: [{ chainId: computeChainId, address: token?.address }],
-                mainProtocol: "badger",
-                depositUrl: BadgerMetadata.generateUrl(computeChainId, params),
-            };
-        }
-        catch {
-            return {
-                action: OpportunityAction.BORROW,
-                name: `Borrow ${params.symbolTargetToken}`,
-                tokens: [{ chainId: computeChainId, address: params.targetToken }],
-                mainProtocol: "badger",
-                depositUrl: BadgerMetadata.generateUrl(computeChainId, params),
-            };
-        }
-    }
-    static generateUrl(_computeChainId, _params) {
-        return "https://www.ebtc.finance/dapp/borrow";
-    }
-}

package/dist/src/engine/implementations/Clamm/metadata.js

@@ -1,176 +0,0 @@
-import { protocolIdList } from "@/modules/v4/protocol/protocol.model";
-import { ProtocolService } from "@/modules/v4/protocol/protocol.service";
-import { camelToKebabCase } from "@/utils/caseChanges";
-import { log } from "@/utils/logger";
-import { sanitizeChainName } from "@/utils/sanitizeChain";
-import { OpportunityAction } from "@db/api";
-import { AMM, ChainId, almName, ammName, } from "@sdk";
-import { getAddress } from "viem";
-export const uniswapV3OkuChains = {
-    [ChainId.BLAST]: "blast",
-    [ChainId.SCROLL]: "scroll",
-    [ChainId.LINEA]: "linea",
-    [ChainId.MANTLE]: "mantle",
-    [ChainId.ZKSYNC]: "zksync",
-    [ChainId.GNOSIS]: "gnosis",
-    [ChainId.BASE]: "base",
-    [ChainId.BSC]: "bsc",
-    [ChainId.MANTA]: "manta",
-    [ChainId.ROOTSTOCK]: "rootstock",
-    [ChainId.TAIKO]: "taiko",
-    [ChainId.MOONBEAM]: "moonbeam",
-    [ChainId.POLYGONZKEVM]: "polygon-zkevm",
-    [ChainId.BOB]: "bob",
-    // [ChainId.WORLDCHAIN]: "world-chain",
-    [ChainId.SONIC]: "sonic",
-    [ChainId.LISK]: "lisk",
-    [ChainId.CORN]: "corn",
-};
-export const pancakeswapChains = {
-    [ChainId.MAINNET]: "eth",
-    [ChainId.ARBITRUM]: "arb",
-    [ChainId.POLYGONZKEVM]: "polygon-zkevm",
-};
-export const sushiswapv3Chains = {
-    [ChainId.SKALE]: "skale-europa",
-};
-export class ClammMetadata {
-    async build(campaign) {
-        const { params, computeChainId } = campaign;
-        let platform = ammName(params.amm);
-        if (platform === "BaseSwap") {
-            switch (computeChainId) {
-                case ChainId.MODE:
-                    platform = "SwapMode";
-                    break;
-                case ChainId.ARBITRUM:
-                    platform = "Arbitex";
-                    break;
-                case ChainId.OPTIMISM:
-                    platform = "SuperSwap";
-            }
-        }
-        if (platform === "Izumi") {
-            if (computeChainId === ChainId.ROOTSTOCK)
-                platform = "WoodSwap";
-            else
-                platform = "iZUMi";
-        }
-        let 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?.type;
-                const forwarderName = !!forwarderType ? almName(forwarderType) : null;
-                if (!!forwarderName) {
-                    whitelistNameString += ` ${forwarderName} `;
-                }
-            }
-        }
-        // Protocol id normalization
-        let mainProtocolId = AMM[params.amm]
-            ? camelToKebabCase(AMM[params.amm].replace(/\/?(V(\d+_)?\d+)/g, ""))
-            : undefined;
-        if (mainProtocolId?.includes("stryke"))
-            mainProtocolId = "stryke";
-        else if (mainProtocolId?.includes("quickswap"))
-            mainProtocolId = "quickswap";
-        else if (mainProtocolId?.includes("quick-swap"))
-            mainProtocolId = "quickswap";
-        else if (mainProtocolId?.includes("sushiswap"))
-            mainProtocolId = "sushi-swap";
-        else if (mainProtocolId?.includes("sushi-swap"))
-            mainProtocolId = "sushi-swap";
-        else if (mainProtocolId?.includes("third-trade"))
-            mainProtocolId = "thirdtrade";
-        const parsedProtocolId = mainProtocolId;
-        if (!!mainProtocolId) {
-            // Make sure the protocol exist in the correct type
-            const protocol = (await ProtocolService.findMany({ id: mainProtocolId }))?.[0];
-            if (!!protocol) {
-                mainProtocolId = protocol?.id;
-            }
-            if (mainProtocolId === "unknown") {
-                mainProtocolId = undefined;
-            }
-        }
-        if (!mainProtocolId || !protocolIdList.includes(mainProtocolId))
-            log.warn(`protocol not found for ${AMM[params.amm]} - parsed as ${parsedProtocolId}`);
-        return {
-            name: `Provide liquidity to ${whitelistNameString} ${platform} ${params.symbolToken0}-${params.symbolToken1}${params.poolFee ? ` ${params.poolFee}%` : ""}`,
-            action: OpportunityAction.POOL,
-            tokens: [
-                { chainId: computeChainId, address: params.token0 },
-                { chainId: computeChainId, address: params.token1 },
-            ],
-            mainProtocol: mainProtocolId,
-            depositUrl: ClammMetadata.generateUrl(computeChainId, params),
-            explorerAddress: getAddress(params.poolAddress),
-        };
-    }
-    static generateUrl(computeChainId, params) {
-        const sanitizeFee = (poolFee) => Number(poolFee) * 10000;
-        const ammLinkMap = {
-            UniswapV3: ({ poolAddress }) => {
-                const availableOnOku = Object.keys(uniswapV3OkuChains).includes(computeChainId?.toString());
-                if (availableOnOku)
-                    return `https://oku.trade/app/${uniswapV3OkuChains[computeChainId]}/liquidity/${params.poolAddress} `;
-                return `https://app.uniswap.org/explore/pools/${sanitizeChainName(computeChainId)}/${poolAddress?.toLowerCase()}`;
-            },
-            // Pool address mappings
-            Sonex: ({ poolAddress }) => `https://app.sonex.so/explore/pools/${poolAddress}`,
-            KYO: ({ poolAddress }) => `https://app.kyo.finance/liquidity/${poolAddress}`,
-            SushiSwapV3: ({ poolAddress }) => `https://www.sushi.com/${sushiswapv3Chains[computeChainId] ?? sanitizeChainName(computeChainId)}/pool/v3/${poolAddress}`,
-            Swapr: ({ poolAddress }) => `https://v3.swapr.eth.limo/#/info/pools/${poolAddress}`,
-            Crust: ({ poolAddress }) => `https://v1.crust.finance/liquidity/${poolAddress}`,
-            ThirdTrade: ({ poolAddress }) => `https://third.trade/pool/${poolAddress}`,
-            Katana: ({ poolAddress }) => `https://app.roninchain.com/liquidity/${poolAddress}`,
-            SyncswapV3: ({ poolAddress }) => `https://syncswap.xyz/pool/${poolAddress}`,
-            // Token address mappings
-            Camelot: ({ token0, token1 }) => `https://app.camelot.exchange/liquidity?type=v3&token1=${token0}&token2=${token1}`,
-            QuickswapAlgebra: ({ token0, token1 }) => `https://quickswap.exchange/#/pools?currency0=${token0}&currency1=${token1}`,
-            QuickswapUni: ({ token0, token1 }) => `https://quickswap.exchange/#/pools?currency0=${token0}&currency1=${token1}`,
-            QuickswapAlgebraV1_2: ({ token0, token1 }) => `https://quickswap.exchange/#/pools?currency0=${token0}&currency1=${token1}`,
-            AERODROME: ({ token0, token1 }) => `https://aerodrome.finance/pools?token0=${token0}&token1=${token1}&type=1&chain=${computeChainId}`,
-            KOI: ({ token0, token1 }) => `https://dapp.koi.finance/pool/v3/new/${token0}/${token1}`,
-            zkSwap: ({ token0, token1 }) => `https://www.zkswap.finance/add/${token0}/${token1}/2000?chain=${computeChainId}`,
-            Velodrome: ({ token0, token1 }) => `https://velodrome.finance/pools?token0=${token0}&token1=${token1}&type=1&chain=${computeChainId}`,
-            // Token address and pool fess
-            PancakeSwapV3: ({ token0, token1, poolFee }) => `https://pancakeswap.finance/add/${token0}/${token1}/${sanitizeFee(poolFee)}?chain=${pancakeswapChains[computeChainId] ?? sanitizeChainName(computeChainId)}`,
-            BaseSwap: ({ token0, token1, poolFee }) => `https://${computeChainId === ChainId.MODE ? "swapmode" : "baseswap"}.fi/addV3?currencyIdA=${token0}&currencyIdB=${token1}&feeAmount=${sanitizeFee(poolFee)}`,
-            Voltage: ({ token0, token1, poolFee }) => `https://app.voltage.finance/add/${token0}/${token1}?version=v3&feeAmount=${sanitizeFee(poolFee)}`,
-            Izumi: ({ token0, token1, poolFee }) => `https://${computeChainId === ChainId.ROOTSTOCK ? "woodswap.org" : "izumi.finance"}/trade/add-liquidity/?token0=${token0}&token1=${token1}&chainId=${computeChainId}&fee=${Number(poolFee) * 10000}`,
-            SupswapV3: ({ token0, token1, poolFee }) => `https://supswap.xyz/add/${token0}/${token1}/${sanitizeFee(poolFee)}`,
-            Iguana: ({ token0, token1, poolFee }) => `https://www.iguanadex.com/add/${token0}/${token1}/${sanitizeFee(poolFee)}?chain=${sanitizeChainName(computeChainId)}`,
-            // Token symbols
-            Stryke: ({ symbolToken0, symbolToken1 }) => `https://www.stryke.xyz/en/trade/arbitrum/${symbolToken0}-${symbolToken1}`,
-            StrykePCS: ({ symbolToken0, symbolToken1 }) => `https://pancakeswap.stryke.xyz/${symbolToken0}-${symbolToken1}?mode=LP`,
-            StrykeSushi: ({ symbolToken0, symbolToken1 }) => `https://sushiswap.stryke.xyz/${symbolToken0}-${symbolToken1}?mode=LP`,
-            // Token symbols and pool fees
-            Neptune: ({ symbolToken0, symbolToken1, poolFee }) => `https://app.nep.finance/add/${symbolToken0}/${symbolToken1}/${sanitizeFee(poolFee)}`,
-            // Protocols without unique links for pools
-            Retro: () => "https://retro.finance/liquidity/managev3",
-            Horiza: () => "https:/app.horiza.io/liquidity",
-            Thruster: () => "https://app.thruster.finance/add",
-            Kim: () => "https://app.kim.exchange/positions",
-            ARTHSWAP: () => "https://app.arthswap.org/#/pools",
-            Fenix: () => "https://www.fenixfinance.io/",
-            Ramses: () => "https://app.ramses.exchange/swap",
-            SwapX: () => "https://swapx.fi/earn",
-            ZERO: () => "https://www.zkzero.fi/",
-            Hyperswap: () => "https://hyperswap.exchange/",
-            SpookyswapV3: () => "https://spooky.fi/",
-        };
-        let ammString = params.amm.toString();
-        try {
-            if (params.amm === Number(Number.parseInt(params.amm.toString()))) {
-                ammString = AMM[params.amm];
-            }
-        }
-        catch { }
-        return ammLinkMap[ammString]?.(params)?.toLowerCase();
-    }
-}

package/dist/src/engine/implementations/Compound/metadata.js

@@ -1,23 +0,0 @@
-import { camelToKebabCase } from "@/utils/caseChanges";
-import { OpportunityAction } from "@db/api";
-import { CompFork, CompoundSubCampaignType } from "@sdk";
-export class CompoundMetadata {
-    async build(campaign) {
-        const { params, computeChainId, subType } = campaign;
-        return {
-            action: subType === CompoundSubCampaignType.supply ? OpportunityAction.LEND : OpportunityAction.BORROW,
-            name: [
-                subType === CompoundSubCampaignType.supply
-                    ? `Supply ${params.symbolUnderlyingToken} on`
-                    : `Borrow ${params.symbolUnderlyingToken} on`,
-                CompFork[params.compFork],
-            ].join(" "),
-            tokens: [
-                { chainId: computeChainId, address: params.underlyingToken },
-                { chainId: computeChainId, address: params.targetToken },
-            ],
-            mainProtocol: camelToKebabCase(CompFork[params.compFork].replace(/\/?(V(\d+_)?\d+)/g, "")),
-            depositUrl: undefined, // TODO, shall depend on compFork
-        };
-    }
-}

package/dist/src/engine/implementations/CompoundV3/metadata.js

@@ -1,23 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { CompoundV3SubCampaignType } from "@sdk";
-export class CompoundV3Metadata {
-    async build(campaign) {
-        const { params, computeChainId } = campaign;
-        const symbolUnderlyingToken = params.symbolTargetToken.slice(1, -2);
-        return {
-            action: params.subCampaignType === CompoundV3SubCampaignType.SUPPLY ? OpportunityAction.LEND : OpportunityAction.BORROW,
-            name: [
-                params.subCampaignType === CompoundV3SubCampaignType.SUPPLY
-                    ? `Supply ${symbolUnderlyingToken} on`
-                    : `Borrow ${symbolUnderlyingToken} on`,
-                "Compound V3",
-            ].join(" "),
-            tokens: [
-                { chainId: computeChainId, address: params.underlyingToken },
-                { chainId: computeChainId, address: params.targetToken },
-            ],
-            mainProtocol: "compound",
-            depositUrl: undefined, // TODO, shall depend on compFork
-        };
-    }
-}

package/dist/src/engine/implementations/Default/metadata.js

@@ -1,12 +0,0 @@
-import { OpportunityAction } from "@db/api";
-export class DefaultMetadata {
-    async build(campaign) {
-        const { rewardToken } = campaign;
-        return {
-            action: OpportunityAction.HOLD,
-            name: "Reward Opportunity",
-            tokens: [],
-            explorerAddress: rewardToken.address,
-        };
-    }
-}

package/dist/src/engine/implementations/Dolomite/metadata.js

@@ -1,20 +0,0 @@
-import { OpportunityAction } from "@db/api";
-import { getAddress } from "viem";
-export class DolomiteMetadata {
-    async build(campaign) {
-        const { params, computeChainId, subType } = campaign;
-        const subtypes = [
-            { name: "Supply (delta)", action: OpportunityAction.LEND },
-            { name: "Supply", action: OpportunityAction.LEND },
-            { name: "Borrow", action: OpportunityAction.BORROW },
-        ];
-        const subtype = subtypes[subType ?? 0];
-        return {
-            action: subtype.action,
-            tokens: [{ chainId: computeChainId, address: params.targetToken }],
-            name: `${subtype.name} ${params.symbolTargetToken}`,
-            mainProtocol: "dolomite",
-            explorerAddress: getAddress(params.targetToken),
-        };
-    }
-}

package/dist/src/engine/implementations/EigenLayer/metadata.js

@@ -1,12 +0,0 @@
-import { OpportunityAction } from "@db/api";
-export class EigenLayerMetadata {
-    async build(campaign) {
-        const { params, computeChainId } = campaign;
-        return {
-            action: OpportunityAction.LEND,
-            name: ["EigenLayer", "strategy for", params.symbolUnderlyingToken].join(" "),
-            tokens: [{ chainId: computeChainId, address: params.underlyingToken }],
-            mainProtocol: "eigenlayer",
-        };
-    }
-}