@merkl/api 0.19.14 → 0.19.16

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

@@ -91,7 +91,9 @@ export declare enum tokenType {
     balancerV3 = "balancerV3",
     hanji_liquidity_vault_token = "hanji_liquidity_vault_token",
     xU308 = "xU308",
-    bunniV2 = "bunniV2"
+    bunniV2 = "bunniV2",
+    beratrax_vault = "beratrax_vault",
+    beraborrow_gauge = "beraborrow_gauge"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

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

@@ -93,6 +93,8 @@ export var tokenType;
     tokenType["hanji_liquidity_vault_token"] = "hanji_liquidity_vault_token";
     tokenType["xU308"] = "xU308";
     tokenType["bunniV2"] = "bunniV2";
+    tokenType["beratrax_vault"] = "beratrax_vault";
+    tokenType["beraborrow_gauge"] = "beraborrow_gauge";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
@@ -186,4 +188,6 @@ export const tokenTypeToProtocol = {
     [tokenType.hanji_liquidity_vault_token]: { protocol: "Hanji", action: OpportunityAction.POOL },
     [tokenType.xU308]: { protocol: "Uranium", action: OpportunityAction.HOLD },
     [tokenType.bunniV2]: { protocol: "Bunni V2", action: OpportunityAction.HOLD },
+    [tokenType.beratrax_vault]: { protocol: "Beratrax", action: OpportunityAction.POOL },
+    [tokenType.beraborrow_gauge]: { protocol: "Beraborrow", action: OpportunityAction.POOL },
 };

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

@@ -0,0 +1,51 @@
+import type { Pricer } from "@/utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import { tokenType, type tokenTypeStruct } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawBG;
+    call: string;
+    target: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
+};
+type callKeysBG = mandatoryCallKeys & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    vaultBalance: string;
+};
+type dataRawBG = callKeysBG & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+type dataTypeBG = dataType & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+    vaultBalance: string;
+};
+export declare class BEXRewardGaugeProcessor extends GenericProcessor<callKeysBG, dataRawBG, dataTypeBG> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound4(typeInfo: dataRawBG): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

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

@@ -0,0 +1,102 @@
+import { decodeCall } from "@/utils/decodeCalls";
+import { createCall } from "@/utils/encodeCalls";
+import { generateCardName } from "@/utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor, Round } from "../GenericProcessor";
+import { tokenType } from "../helpers/tokenType";
+export class BEXRewardGaugeProcessor extends GenericProcessor {
+    rounds = {
+        round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
+        round2: [
+            { key: "balanceUnderlyingPoolTokens", call: "totalAssets", target: "tokenAddress" },
+            { key: "totalSupplyUnderlyingPoolTokens", call: "totalSupply", target: "gyroscopeToken" },
+            { key: "poolId", call: "getPoolId", target: "gyroscopeToken" },
+            { key: "vault", call: "getVault", target: "gyroscopeToken" },
+        ],
+        round3: [
+            { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
+            { key: "vaultBalance", call: "balanceOf", target: "gyroscopeToken", metaData: "vault" },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound4(typeInfo) {
+        const tokens = typeInfo.poolTokensRaw[0];
+        const balances = typeInfo.poolTokensRaw[1];
+        let i = 0;
+        const poolTokens = [];
+        for (const token of tokens) {
+            poolTokens.push({
+                token: token,
+                balance: balances[i].toString(),
+            });
+            i++;
+            typeInfo.poolTokens = poolTokens;
+        }
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        const poolTokensinfo = {};
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let tvlUnderlyingPool = 0;
+        const symbols = [];
+        let indexUpdated = index + this.rounds.round4.length;
+        for (const poolToken of typeInfo.poolTokens) {
+            const symbol = decodeCall(calls, indexUpdated++, "symbol");
+            const decimals = decodeCall(calls, indexUpdated++, "decimals");
+            poolTokensinfo[poolToken.token] = {
+                symbol: symbol,
+                decimals: decimals,
+                amountInPool: BN2Number(poolToken.balance, decimals),
+                price: (await pricer.get({ symbol: symbol })) ?? 0,
+            };
+            tvlUnderlyingPool += poolTokensinfo[poolToken.token].price * poolTokensinfo[poolToken.token].amountInPool;
+            symbols.push(symbol);
+        }
+        let adjustedPoolTotalSupply = BN2Number(typeInfo.totalSupplyUnderlyingPoolTokens, 18) - BN2Number(typeInfo.vaultBalance, 18);
+        if (type === tokenType.beratrax_vault) {
+            // Weird edge case where the total supply is 80k higher than it should be because they minted stuff on an EOA
+            adjustedPoolTotalSupply -= 35724494.54 + 82793;
+        }
+        let percentageOfSupplyUnderlyingPoolTokens = 1;
+        if (adjustedPoolTotalSupply > 0) {
+            percentageOfSupplyUnderlyingPoolTokens =
+                BN2Number(typeInfo.balanceUnderlyingPoolTokens, 18) / adjustedPoolTotalSupply;
+        }
+        const tvl = tvlUnderlyingPool * percentageOfSupplyUnderlyingPoolTokens;
+        const priceTargetToken = tvl / totalSupply;
+        // If one of the symbols in the symbol list contains 2 of the other symbols of the list, remove it
+        // It's a weird edge case that happens with the BEX pools
+        const symbolToRemove = symbols.find(symbol => symbols.filter(s => symbol.includes(s)).length > 1);
+        if (symbolToRemove) {
+            symbols.splice(symbols.indexOf(symbolToRemove), 1);
+        }
+        return {
+            ...typeInfo,
+            totalSupply: totalSupply,
+            poolTokens: poolTokensinfo,
+            tvl: tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken: priceTargetToken,
+            cardName: generateCardName(type, typeInfo, campaign, symbols),
+        };
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        // This is to enforce type checking
+        const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
+        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
+        this.processingRound4(typeInfo);
+        const poolCalls = [createCall(typeInfo.tokenAddress, "totalSupply")];
+        for (const poolToken of typeInfo.poolTokens) {
+            poolCalls.push(createCall(poolToken.token, "symbol"));
+            poolCalls.push(createCall(poolToken.token, "decimals"));
+        }
+        return {
+            type: type,
+            calls: blacklistedLiquidityCalls.concat(poolCalls),
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

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

@@ -4,6 +4,7 @@ import { AaveProcessor } from "./AaveProcessor";
 import { AnglesLiquidProcessor } from "./AnglesLiquid";
 import { AssetProcessor } from "./AssetProcessor";
 import { AuraProcessor } from "./AuraProcessor";
+import { BEXRewardGaugeProcessor } from "./BEXRewardGaugeProcessor";
 import { BalancerGaugeProcessor } from "./BalancerGaugeProcessor";
 import { BalancerPoolProcessor } from "./BalancerPoolProcessor";
 import { BalancerV3PoolProcessor } from "./BalancerV3PoolProcessor";
@@ -136,4 +137,6 @@ export const processorMapping = {
     [tokenType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
     [tokenType.xU308]: xU308Processor,
     [tokenType.bunniV2]: BunniV2Processor,
+    [tokenType.beraborrow_gauge]: BEXRewardGaugeProcessor,
+    [tokenType.beratrax_vault]: BEXRewardGaugeProcessor,
 };

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound1.js

@@ -25,6 +25,10 @@ function satisfiesNameConditions(name, type) {
             return (lowerCaseName.includes("balancer") &&
                 !lowerCaseName.includes("aura deposit vault") &&
                 !lowerCaseName.startsWith("vifi"));
+        case tokenType.beraborrow_gauge:
+            return lowerCaseName.includes("beraborrow") && lowerCaseName.includes("bpt");
+        case tokenType.beratrax_vault:
+            return lowerCaseName.startsWith("beratrax vault");
         case tokenType.gearbox:
             return lowerCaseName.includes("farming of") || lowerCaseName.startsWith("trade");
         case tokenType.euler_borrow:

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

@@ -1,6 +1,6 @@
 import { Campaign } from "@sdk";
 import { AjnaMetadata } from "./implementations/Ajna";
-import { AmbientMetadata } from "./implementations/Ambiant";
+import { AmbientMetadata } from "./implementations/Ambient";
 import { BadgerMetadata } from "./implementations/Badger";
 import { ClammMetadata } from "./implementations/Clamm";
 import { CompoundMetadata } from "./implementations/Compound";

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

@@ -1,4 +1,4 @@
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
 import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.AJNA;
 export declare class AjnaMetadata implements MetadataBuilder<campaignType> {
@@ -10,6 +10,8 @@ export declare class AjnaMetadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: string;
+        depositUrl: string;
     }>;
+    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string;
 }
 export {};

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

@@ -1,5 +1,6 @@
 import { TokenService } from "@/modules/v4/token/token.service";
 import { OpportunityAction } from "@db/api";
+import { NETWORK_LABELS } from "@sdk";
 export class AjnaMetadata {
     async build(computeChainId, params, subType) {
         try {
@@ -29,6 +30,7 @@ export class AjnaMetadata {
                     { chainId: computeChainId, address: quote.address },
                 ],
                 mainProtocol: "ajna",
+                depositUrl: AjnaMetadata.generateUrl(computeChainId, params),
             };
         }
         catch (_err) {
@@ -46,7 +48,11 @@ export class AjnaMetadata {
                     { chainId: computeChainId, address: params.quoteToken },
                 ],
                 mainProtocol: "ajna",
+                depositUrl: AjnaMetadata.generateUrl(computeChainId, params),
             };
         }
     }
+    static generateUrl(computeChainId, params) {
+        return `https://ajnafi.com/${NETWORK_LABELS[computeChainId].toLowerCase()}/pools/${params.poolId}`;
+    }
 }

package/dist/src/engine/opportunityMetadata/implementations/{Ambiant.d.ts → Ambient.d.ts}

@@ -10,6 +10,8 @@ export declare class AmbientMetadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: string;
+        depositUrl: string;
     }>;
+    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string;
 }
 export {};

package/dist/src/engine/opportunityMetadata/implementations/{Ambiant.js → Ambient.js}

@@ -1,5 +1,5 @@
 import { OpportunityAction } from "@db/api";
-import { almName, } from "@sdk";
+import { NETWORK_LABELS, almName, } from "@sdk";
 import { getAddress } from "viem";
 export class AmbientMetadata {
     async build(computeChainId, params, _subType) {
@@ -26,6 +26,10 @@ export class AmbientMetadata {
                 { 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/opportunityMetadata/implementations/Badger.d.ts

@@ -10,6 +10,8 @@ export declare class BadgerMetadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: string;
+        depositUrl: string;
     }>;
+    static generateUrl(_computeChainId: ChainId, _params: CampaignParameters<campaignType>["campaignParameters"]): string;
 }
 export {};

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

@@ -11,6 +11,7 @@ export class BadgerMetadata {
                 name: `Borrow ${token.symbol}`,
                 tokens: [{ chainId: computeChainId, address: token?.address }],
                 mainProtocol: "badger",
+                depositUrl: BadgerMetadata.generateUrl(computeChainId, params),
             };
         }
         catch {
@@ -19,7 +20,11 @@ export class BadgerMetadata {
                 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/opportunityMetadata/implementations/Clamm.d.ts

@@ -1,6 +1,31 @@
 import { type Campaign as CampaignEnum, type CampaignParameters, ChainId } from "@sdk";
 import type { MetadataBuilder } from "../interface";
 type campaignType = CampaignEnum.CLAMM;
+export declare const uniswapV3OkuChains: {
+    [ChainId.BLAST]: string;
+    [ChainId.SCROLL]: string;
+    [ChainId.LINEA]: string;
+    [ChainId.MANTLE]: string;
+    [ChainId.ZKSYNC]: string;
+    [ChainId.GNOSIS]: string;
+    [ChainId.BASE]: string;
+    [ChainId.BSC]: string;
+    [ChainId.MANTA]: string;
+    [ChainId.ROOTSTOCK]: string;
+    [ChainId.TAIKO]: string;
+    [ChainId.MOONBEAM]: string;
+    [ChainId.POLYGONZKEVM]: string;
+    [ChainId.BOB]: string;
+    [ChainId.SONIC]: string;
+    [ChainId.LISK]: string;
+    [ChainId.CORN]: string;
+};
+export declare const pancakeswapChains: {
+    [C in ChainId]?: string;
+};
+export declare const sushiswapv3Chains: {
+    [C in ChainId]?: string;
+};
 export declare class ClammMetadata implements MetadataBuilder<campaignType> {
     build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): Promise<{
         name: string;
@@ -10,6 +35,8 @@ export declare class ClammMetadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: string | undefined;
+        depositUrl: string | undefined;
     }>;
+    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string | undefined;
 }
 export {};

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

@@ -1,7 +1,35 @@
 import { camelToKebabCase } from "@/utils/caseChanges";
 import { OpportunityAction } from "@db/api";
-import { AMM, ChainId, almName, ammName, } from "@sdk";
+import { AMM, ChainId, NETWORK_LABELS, 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(computeChainId, params) {
         let platform = ammName(params.amm);
@@ -45,6 +73,122 @@ export class ClammMetadata {
                 { chainId: computeChainId, address: params.token1 },
             ],
             mainProtocol: AMM[params.amm] ? camelToKebabCase(AMM[params.amm]) : undefined,
+            depositUrl: ClammMetadata.generateUrl(computeChainId, params),
         };
     }
+    static generateUrl(computeChainId, params) {
+        switch (params.amm) {
+            case AMM.UniswapV3: {
+                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/${computeChainId === ChainId.MAINNET
+                    ? "ethereum/"
+                    : `${NETWORK_LABELS[computeChainId]?.toLowerCase().replaceAll(" ", "")}/`}${params?.poolAddress?.toLowerCase()}`;
+            }
+            case AMM.PancakeSwapV3: {
+                return `https://pancakeswap.finance/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}/${Number(params.poolFee) * 10000}?chain=${pancakeswapChains[computeChainId] ?? NETWORK_LABELS[computeChainId]?.replaceAll(" ", "")}`;
+            }
+            case AMM.Sonex: {
+                return `https://app.sonex.so/explore/pools/${params.poolAddress?.toLowerCase()}`;
+            }
+            case AMM.KYO: {
+                return `https://app.kyo.finance/liquidity/${params.poolAddress?.toLowerCase()}`;
+            }
+            case AMM.SushiSwapV3: {
+                return `https://www.sushi.com/${sushiswapv3Chains[computeChainId] ?? NETWORK_LABELS[computeChainId]?.toLowerCase()?.replaceAll(" ", "")}/pool/v3/${params.poolAddress?.toLowerCase()}`;
+            }
+            case AMM.Retro: {
+                return "https://retro.finance/liquidity/managev3";
+            }
+            case AMM.Camelot: {
+                return `https://app.camelot.exchange/liquidity?type=v3&token1=${params.token0?.toLowerCase()}&token2=${params.token1?.toLowerCase()}`;
+            }
+            case AMM.BaseSwap: {
+                return `https://${computeChainId === ChainId.MODE ? "swapmode" : "baseswap"}.fi/addV3?currencyIdA=${params.token0}&currencyIdB=${params.token1}&feeAmount=${Number(params.poolFee) * 10000}`;
+            }
+            case AMM.Horiza: {
+                return "https:/app.horiza.io/liquidity";
+            }
+            case AMM.QuickswapAlgebra: {
+                return `https://quickswap.exchange/pools?currency0=${params.token0}&currency1=${params.token1}`;
+            }
+            case AMM.QuickswapUni: {
+                return `https://quickswap.exchange/pools?currency0=${params.token0}&currency1=${params.token1}`;
+            }
+            case AMM.QuickswapAlgebraV1_2: {
+                return `https://quickswap.exchange/pools?currency0=${params.token0}&currency1=${params.token1}`;
+            }
+            case AMM.Swapr: {
+                return "https://v3.swapr.eth.limo/#/swap";
+            }
+            case AMM.ZERO: {
+                return "https://v3.swapr.eth.limo/#/swap";
+            }
+            case AMM.Crust: {
+                return "https://app.crust.finance/liquidity";
+            }
+            case AMM.Thruster: {
+                return "https://app.thruster.finance/add";
+            }
+            case AMM.Kim: {
+                return "https://app.kim.exchange/positions";
+            }
+            case AMM.Stryke: {
+                return "https://www.stryke.xyz/en/dashboard";
+            }
+            case AMM.StrykePCS: {
+                return `https://pancakeswap.stryke.xyz/${params.symbolToken0}-${params.symbolToken1}?mode=LP`;
+            }
+            case AMM.StrykeSushi: {
+                return `https://sushiswap.stryke.xyz/${params.symbolToken0}-${params.symbolToken1}?mode=LP`;
+            }
+            case AMM.ARTHSWAP: {
+                return "https://app.arthswap.org/#/pools";
+            }
+            case AMM.Fenix: {
+                return "https://www.fenixfinance.io/";
+            }
+            case AMM.Ramses: {
+                return "https://app.ramses.exchange/swap";
+            }
+            case AMM.Voltage: {
+                return `https://app.voltage.finance/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}?version=v3&feeAmount=${Number(params.poolFee) * 10000}`;
+            }
+            case AMM.Izumi: {
+                return `https://${computeChainId === ChainId.ROOTSTOCK ? "woodswap.org" : "izumi.finance"}/trade/add-liquidity/?token0=${params.token0}&token1=${params.token1}&chainId=${computeChainId}&fee=${Number(params.poolFee) * 10000}`;
+            }
+            case AMM.KOI: {
+                return `https://dapp.koi.finance/pool/v3/new/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}`;
+            }
+            case AMM.SupswapV3: {
+                return `https://supswap.xyz/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}/${Number.parseInt(params.poolFee) * 10000}`;
+            }
+            case AMM.zkSwap: {
+                return `https://www.zkswap.finance/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}/2000?chain=${computeChainId}`;
+            }
+            case AMM.SyncswapV3: {
+                return "https://www.syncswap.xyz/pools";
+            }
+            case AMM.Neptune: {
+                return "https://app.nep.finance/add/";
+            }
+            case AMM.SwapX: {
+                return "https://swapx.fi/earn";
+            }
+            case AMM.Velodrome: {
+                return "https://app.velodrome.finance/";
+            }
+            case AMM.AERODROME: {
+                return "https://app.aerodrome.finance/";
+            }
+            case AMM.ThirdTrade: {
+                return "https://app.thirdtrade.xyz/";
+            }
+            case AMM.Katana: {
+                return "https://app.roninchain.com/liquidity";
+            }
+        }
+    }
 }

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

@@ -11,6 +11,8 @@ export declare class CompoundMetadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: ProtocolId;
+        depositUrl: string;
     }>;
+    static generateUrl(_computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string;
 }
 export {};

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

@@ -15,6 +15,10 @@ export class CompoundMetadata {
                 { chainId: computeChainId, address: params.targetToken },
             ],
             mainProtocol: CompFork[params.compFork].toLowerCase(),
+            depositUrl: CompoundMetadata.generateUrl(computeChainId, params),
         };
     }
+    static generateUrl(_computeChainId, params) {
+        return `https://www.compound.blue/${params.targetToken.toLowerCase()}}`;
+    }
 }

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

@@ -10,6 +10,8 @@ export declare class Erc20Metadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: any;
+        depositUrl: any;
     }>;
+    static generateUrl(_computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): any;
 }
 export {};

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

@@ -66,6 +66,10 @@ export class Erc20Metadata {
             name,
             tokens,
             mainProtocol: mainProtocolId,
+            depositUrl: Erc20Metadata.generateUrl(computeChainId, params),
         };
     }
+    static generateUrl(_computeChainId, params) {
+        return params.url;
+    }
 }

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

@@ -10,6 +10,8 @@ export declare class EulerMetadata implements MetadataBuilder<campaignType> {
         }[];
         action: "LEND" | "BORROW";
         mainProtocol: string;
+        depositUrl: string;
     }>;
+    static generateUrl(_computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string;
 }
 export {};

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

@@ -29,6 +29,10 @@ export class EulerMetadata {
             ],
             action: [OpportunityAction.LEND, OpportunityAction.BORROW, OpportunityAction.BORROW][subType],
             mainProtocol: "euler",
+            depositUrl: EulerMetadata.generateUrl(computeChainId, params),
         };
     }
+    static generateUrl(_computeChainId, params) {
+        return `https://app.euler.finance/vault/${params.evkAddress}`;
+    }
 }

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

@@ -10,11 +10,14 @@ export declare class EventBasedMetadata implements MetadataBuilder<campaignType>
             address: any;
         }[];
         mainProtocol: string;
+        depositUrl: any;
     } | {
         action: string;
         name: string;
         tokens: never[];
         mainProtocol: undefined;
+        depositUrl?: undefined;
     }>;
+    static generateUrl(_computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): any;
 }
 export {};

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

@@ -31,6 +31,7 @@ export class EventBasedMetadata {
                 name,
                 tokens,
                 mainProtocol: mainProtocolId.toLowerCase(),
+                depositUrl: EventBasedMetadata.generateUrl(computeChainId, params),
             };
         }
         catch {
@@ -42,4 +43,7 @@ export class EventBasedMetadata {
             };
         }
     }
+    static generateUrl(_computeChainId, params) {
+        return params.url;
+    }
 }

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

@@ -10,6 +10,8 @@ export declare class HyperdriveMetadata implements MetadataBuilder<campaignType>
             address: any;
         }[];
         mainProtocol: string;
+        depositUrl: string;
     }>;
+    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): string;
 }
 export {};

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

@@ -16,6 +16,11 @@ export class HyperdriveMetadata {
             name: [subtypeData.name, params.symbolTargetToken].join(" "),
             tokens: [{ chainId: computeChainId, address: params.targetToken }],
             mainProtocol: "hyperdrive",
+            depositUrl: HyperdriveMetadata.generateUrl(computeChainId, params, subType),
         };
     }
+    static generateUrl(computeChainId, params, subType) {
+        const campaignType = subType === 0 ? "lp" : subType === 1 ? "long" : "short";
+        return `https://app.hyperdrive.box/market/${computeChainId}/${params.targetToken}?position=${campaignType}`;
+    }
 }