@merkl/api 0.9.15

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

@@ -0,0 +1,336 @@
+import { decodeCall, decodeReturnValue } from "@/utils/decodeCalls";
+import { enzymeFundValueCalculatorRouterMapping, getTypeFromFactoryAddress } from "./helpers/factoryFinder";
+import { getTypeFromAddressChain } from "./helpers/hardcoded";
+import { getTypeFromOwnerAddress } from "./helpers/ownerFinder";
+import { tokenType } from "./helpers/tokenType";
+import { processorMapping } from "./implementations/processorMapping";
+function satisfiesNameConditions(name, type) {
+    const lowerCaseName = name.toLowerCase();
+    switch (type) {
+        case tokenType.hourglass:
+            return lowerCaseName.startsWith("ct-hourglass");
+        case tokenType.fraxlend:
+            return lowerCaseName.includes("fraxlend interest bearing");
+        case tokenType.sturdy_aggregator:
+            return lowerCaseName.includes("aggregator");
+        case tokenType.sturdy_silo:
+            return lowerCaseName.includes("sturdy interest bearing");
+        case tokenType.aura:
+            return lowerCaseName.includes("aura deposit vault");
+        case tokenType.poolside:
+            return lowerCaseName.includes("poolside");
+        case tokenType.anglesLiquid:
+            return lowerCaseName.includes("angles liquid");
+        case tokenType.balancerGauge:
+            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:
+            return lowerCaseName.startsWith("debt token of evk vault");
+        case tokenType.euler_lend:
+            return lowerCaseName.includes("evk vault");
+        case tokenType.fluid:
+            return lowerCaseName.startsWith("fluid");
+        case tokenType.filament:
+            return lowerCaseName.startsWith("filament");
+        case tokenType.radiant_lend:
+            return lowerCaseName.includes("radiant interest");
+        case tokenType.radiant_borrow:
+            return lowerCaseName.includes("radiant variable debt");
+        case tokenType.ionic:
+            return lowerCaseName.includes("ionic");
+        case tokenType.venus:
+            return lowerCaseName.startsWith("venus");
+        case tokenType.reactor_fusion:
+            return lowerCaseName.startsWith("reactorfusion");
+        case tokenType.rfx:
+            return lowerCaseName.includes("rfx");
+        case tokenType.rfx_slv:
+            return lowerCaseName.includes("rfx") && lowerCaseName.includes("shared liquidity vault");
+        case tokenType.layerbank:
+            return lowerCaseName.includes("layerbank");
+        case tokenType.moonwell:
+            return lowerCaseName.includes("moonwell");
+        case tokenType.curve_2:
+            return (lowerCaseName === "crvusd/frax" ||
+                lowerCaseName === "ezeth/wfrxeth" ||
+                lowerCaseName === "pufeth/wsteth" ||
+                lowerCaseName === "hai/lusd" ||
+                lowerCaseName === "weth/pufeth");
+        case tokenType.crosscurve:
+            return lowerCaseName.startsWith("crosscurve") || lowerCaseName === "eywa/usdt";
+        case tokenType.curveNPool:
+            return lowerCaseName === "zai/usdc" || lowerCaseName === "zai/szai";
+        case tokenType.silostaking:
+            return lowerCaseName === "isei";
+        case tokenType.beefy:
+            return lowerCaseName.startsWith("moo velo");
+        case tokenType.uniswapv2:
+            return lowerCaseName.includes("uniswap") && lowerCaseName !== "uniswap";
+        case tokenType.fenix:
+            return lowerCaseName.includes("stablev1 amm");
+        case tokenType.ra:
+            return lowerCaseName.includes("volatile pair -") || lowerCaseName.includes("correlated pair -");
+        case tokenType.syncswap:
+            return lowerCaseName.includes("syncswap");
+        case tokenType.aave_lending:
+            return lowerCaseName.includes("aave");
+        case tokenType.aave_borrowing:
+            return lowerCaseName.includes("aave") && lowerCaseName.includes("debt");
+        case tokenType.vicuna_lending:
+            return lowerCaseName.startsWith("vicuna sonic") && !lowerCaseName.includes("debt");
+        case tokenType.vicuna_borrowing:
+            return lowerCaseName.startsWith("vicuna sonic variable debt");
+        case tokenType.yei_borrowing:
+            return ((lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"))) &&
+                lowerCaseName.includes("debt"));
+        case tokenType.ironclad_borrowing:
+            return ((lowerCaseName.startsWith("ironclad") ||
+                (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
+                lowerCaseName.includes("debt") &&
+                name.toLowerCase() !== "ironclad token");
+        case tokenType.zerolend_borrowing:
+            return lowerCaseName.includes("zerolend") && lowerCaseName.includes("debt");
+        case tokenType.yei_lending:
+            return lowerCaseName.startsWith("yei") || (lowerCaseName.includes("aave") && lowerCaseName.includes("yei"));
+        case tokenType.ironclad_lending:
+            return ((lowerCaseName.startsWith("ironclad") ||
+                (lowerCaseName.includes("aave") && lowerCaseName.includes("ironclad"))) &&
+                name.toLowerCase() !== "ironclad token");
+        case tokenType.zerolend_lending:
+            return lowerCaseName.includes("zerolend");
+        case tokenType.compound:
+            return lowerCaseName.includes("compound");
+        case tokenType.ironcladStaking:
+            return lowerCaseName === "ironclad token";
+        case tokenType.woofi:
+            return lowerCaseName.includes("woofi");
+        case tokenType.maverickBoostedPosition:
+            return lowerCaseName.includes("maverick");
+        case tokenType.zkSwapThreePool:
+            return lowerCaseName.includes("zf");
+        case tokenType.maha:
+            return lowerCaseName.includes("staked") && lowerCaseName.includes("maha");
+        case tokenType.tempest:
+            return lowerCaseName.startsWith("ts");
+        case tokenType.tempestStaking:
+            return lowerCaseName.startsWith("tempest");
+        case tokenType.holdstation:
+            return lowerCaseName.startsWith("hs");
+        case tokenType.noLinkVault:
+            return lowerCaseName.startsWith("unifi");
+        case tokenType.vicuna:
+            return lowerCaseName.startsWith("vifi");
+        case tokenType.avalon_borrowing:
+            return lowerCaseName.includes("avalon") && lowerCaseName.includes("debt");
+        case tokenType.avalon_lending:
+            return lowerCaseName.includes("avalon");
+        case tokenType.superlend_borrowing:
+            return lowerCaseName.includes("superlend") && lowerCaseName.includes("debt");
+        case tokenType.superlend_lending:
+            return lowerCaseName.includes("superlend");
+        case tokenType.lendle_borrowing:
+            return lowerCaseName.includes("lendle") && lowerCaseName.includes("debt");
+        case tokenType.lendle_lending:
+            return lowerCaseName.includes("lendle");
+        case tokenType.takotako_borrowing:
+            return lowerCaseName.includes("takotako") && lowerCaseName.includes("debt");
+        case tokenType.takotako_lending:
+            return lowerCaseName.includes("takotako");
+        case tokenType.cian:
+            return lowerCaseName.includes("cian");
+        case tokenType.concrete:
+            return lowerCaseName.includes("concrete");
+        case tokenType.equalizer_gauge:
+            return lowerCaseName.includes("equalizer");
+        case tokenType.spectra_lpt:
+            return lowerCaseName.includes("spectra") && lowerCaseName.includes("curve");
+        case tokenType.spectra_yt:
+            return lowerCaseName.includes("yield") && lowerCaseName.includes("token");
+        case tokenType.bunniV2:
+            return lowerCaseName.includes("bunni");
+        default:
+            return false;
+    }
+}
+function generateResult(type, name, targetToken, typeInfo, campaign) {
+    const ProcessorClass = processorMapping[type];
+    if (!ProcessorClass) {
+        throw new Error(`Processor not found for key: ${type}`);
+    }
+    const processorObject = new ProcessorClass();
+    if (campaign)
+        typeInfo = { ...typeInfo, ...parseForStaking(campaign) };
+    typeInfo = {
+        ...typeInfo,
+        name: name,
+        tokenAddress: targetToken,
+        totalSupply: 0,
+        blacklistedSupply: 0,
+    };
+    return processorObject.computeRound1(type, typeInfo);
+}
+function processNamingConditions(type, name, targetToken, campaign) {
+    if (satisfiesNameConditions(name, type)) {
+        return generateResult(type, name, targetToken, {}, campaign);
+    }
+}
+function processNamingConditionsInOrder(types, name, targetToken, campaign) {
+    for (const type of types) {
+        const result = processNamingConditions(type, name, targetToken, campaign);
+        if (result)
+            return result;
+    }
+}
+function parseForFactory(calls, targetToken, campaign) {
+    try {
+        const factory = decodeReturnValue(calls.factory, "factory");
+        const name = decodeReturnValue(calls.name, "name");
+        const type = getTypeFromFactoryAddress(factory);
+        if (type !== tokenType.unknown)
+            return generateResult(type, name, targetToken, { factory }, campaign);
+    }
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+}
+function parseForOwner(calls, targetToken) {
+    try {
+        const owner = decodeReturnValue(calls.owner, "owner");
+        const name = decodeReturnValue(calls.name, "name");
+        const type = getTypeFromOwnerAddress(owner);
+        if (type !== tokenType.unknown)
+            return generateResult(type, name, targetToken, { owner: owner });
+    }
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+}
+function parseForEnzyme(calls, targetToken) {
+    // Enzyme check
+    try {
+        const dispatcher = decodeReturnValue(calls.creator, "getCreator");
+        const name = decodeReturnValue(calls.name, "name");
+        const type = getTypeFromFactoryAddress(dispatcher);
+        const fundValueCalculator = enzymeFundValueCalculatorRouterMapping[dispatcher];
+        const typeInfo = {
+            fundValueCalculator,
+            dispatcher,
+        };
+        if (type === tokenType.enzyme) {
+            return generateResult(type, name, targetToken, typeInfo);
+        }
+    }
+    catch (e) {
+        // No factory on this token
+    }
+}
+function parseForMetamorpho(calls, targetToken) {
+    // MetaMorpho check
+    try {
+        decodeReturnValue(calls.metamorpho, "MORPHO");
+        const name = decodeReturnValue(calls.name, "name");
+        return generateResult(tokenType.metamorpho, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a metamorpho token
+    }
+}
+function parseForBalancer(calls, targetToken, name) {
+    // Check for balancer pools
+    try {
+        decodeReturnValue(calls.poolId, "getPoolId");
+        return generateResult(tokenType.balancerPool, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a balancer pool
+    }
+    try {
+        decodeReturnValue(calls.vault, "getVault");
+        return generateResult(tokenType.balancerV3, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a balancer v3 pool
+    }
+}
+function checkAgainstHardcoded(calls, chainId, targetToken) {
+    // Check for balancer pools
+    try {
+        const name = decodeReturnValue(calls.name, "name");
+        const type = getTypeFromAddressChain(chainId, targetToken);
+        if (type !== tokenType.unknown)
+            return generateResult(type, name, targetToken, {});
+    }
+    catch (e) {
+        // Not a hardcoded address
+    }
+}
+function parseForStaking(campaign) {
+    try {
+        const whitelist = campaign.campaignParameters.whitelist;
+        if (whitelist.length === 1) {
+            const forwarders = campaign.campaignParameters.forwarders;
+            if (forwarders.length === 1) {
+                if (forwarders[0].sender === whitelist[0]) {
+                    return { isStaking: "true", stakingContract: whitelist[0] };
+                }
+            }
+        }
+    }
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+    return { isStaking: "false" };
+}
+export function getTokenTypeRound1(calls, targetToken, index, campaign) {
+    const returnValueOfCalls = calls.map(call => call.returnData);
+    const returnValue = {
+        factory: returnValueOfCalls[index],
+        metamorpho: returnValueOfCalls[index + 1],
+        name: returnValueOfCalls[index + 2],
+        poolId: returnValueOfCalls[index + 3],
+        creator: returnValueOfCalls[index + 4],
+        owner: returnValueOfCalls[index + 5],
+        vault: returnValueOfCalls[index + 6],
+    };
+    let result = parseForFactory(returnValue, targetToken, campaign);
+    if (result)
+        return result;
+    result = parseForOwner(returnValue, targetToken);
+    if (result)
+        return result;
+    result = checkAgainstHardcoded(returnValue, campaign.computeChainId, targetToken);
+    if (result)
+        return result;
+    result = parseForEnzyme(returnValue, targetToken);
+    if (result)
+        return result;
+    result = parseForMetamorpho(returnValue, targetToken);
+    if (result)
+        return result;
+    let name;
+    try {
+        name = decodeCall(returnValueOfCalls, index + 2, "name");
+    }
+    catch {
+        return generateResult(tokenType.unknown, "Unknown", targetToken, {}, campaign);
+    }
+    result = parseForBalancer(returnValue, targetToken, name);
+    if (result)
+        return result;
+    // Order matters
+    const ordered_token_Type = Object.values(tokenType).filter(value => typeof value === "string");
+    result = processNamingConditionsInOrder(ordered_token_Type, name, targetToken, campaign);
+    if (result)
+        return result;
+    return generateResult(tokenType.unknown, name, targetToken, {}, campaign);
+}

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound2.d.ts

@@ -0,0 +1,4 @@
+import type { CampaignParameters, ResultDto } from "@sdk";
+import type { ERC20SupportedCampaignType } from "../dynamicData/implementations/Erc20";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: ResultDto[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;

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

@@ -0,0 +1,22 @@
+import { processorMapping } from "./implementations/processorMapping";
+export function getTokenTypeRound2(index, type, typeInfo, calls, campaign) {
+    try {
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        const ProcessorClass = processorMapping[type];
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound2(index, type, typeInfo, returnValueOfCalls, campaign);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound3.d.ts

@@ -0,0 +1,3 @@
+import type { ResultDto } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: ResultDto[]): tokenTypeStruct;

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

@@ -0,0 +1,22 @@
+import { processorMapping } from "./implementations/processorMapping";
+export function getTokenTypeRound3(index, type, typeInfo, calls) {
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound3(index, type, typeInfo, returnValueOfCalls);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

package/dist/src/engine/erc20SubTypeProcessors/subtypesRound4.d.ts

@@ -0,0 +1,3 @@
+import type { Campaign, CampaignParameters, ResultDto } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: ResultDto[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

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

@@ -0,0 +1,22 @@
+import { processorMapping } from "./implementations/processorMapping";
+export function getTokenTypeRound4(index, type, typeInfo, calls, campaign) {
+    try {
+        const ProcessorClass = processorMapping[type];
+        const returnValueOfCalls = calls.map(call => call.returnData);
+        if (!ProcessorClass) {
+            throw new Error(`Processor not found for key: ${type}`);
+        }
+        const processorObject = new ProcessorClass();
+        return processorObject.computeRound4(index, type, typeInfo, returnValueOfCalls, campaign);
+    }
+    catch (error) {
+        console.error(error);
+        return {
+            type: type,
+            calls: [],
+            typeInfo: {
+                ...typeInfo,
+            },
+        };
+    }
+}

package/dist/src/engine/opportunityMetadata/factory.d.ts

@@ -0,0 +1,3 @@
+import { Campaign } from "@sdk";
+import type { MetadataBuilder } from "./interface";
+export declare const metadataBuilderFactory: (campaignType: Campaign) => MetadataBuilder<typeof campaignType>;

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

@@ -0,0 +1,57 @@
+import { Campaign } from "@sdk";
+import { AjnaMetadata } from "./implementations/Ajna";
+import { AmbientMetadata } from "./implementations/Ambiant";
+import { BadgerMetadata } from "./implementations/Badger";
+import { ClammMetadata } from "./implementations/Clamm";
+import { CompoundMetadata } from "./implementations/Compound";
+import { DefaultMetadata } from "./implementations/Default";
+import { DolomiteMetadata } from "./implementations/Dolomite";
+import { EigenLayerMetadata } from "./implementations/EigenLayer";
+import { EncompassingMetadata } from "./implementations/Encompassing";
+import { Erc20Metadata } from "./implementations/Erc20";
+import { EulerMetadata } from "./implementations/Euler";
+import { EventBasedMetadata } from "./implementations/EventBased";
+import { HyperdriveMetadata } from "./implementations/Hyperdrive";
+import { InvalidMetadata } from "./implementations/Invalid";
+import { IonMetadata } from "./implementations/Ion";
+import { JsonAirdropMetadata } from "./implementations/JsonAirdrop";
+import { MorphoMetadata } from "./implementations/Morpho";
+import { RadiantMetadata } from "./implementations/Radiant";
+import { SiloMetadata } from "./implementations/Silo";
+import { UniswapV4Metadata } from "./implementations/UniswapV4";
+import { VestMetadata } from "./implementations/Vest";
+// @dev Casts are made to enforce type safety
+// @dev A type error must be thrown if a new campaign type is added and the corresponding builder is not implemented
+const map = {
+    [Campaign.INVALID]: new InvalidMetadata(),
+    [Campaign.ERC20]: new Erc20Metadata(),
+    [Campaign.CLAMM]: new ClammMetadata(),
+    [Campaign.ERC20_SNAPSHOT]: new Erc20Metadata(),
+    [Campaign.JSON_AIRDROP]: new JsonAirdropMetadata(),
+    [Campaign.SILO]: new SiloMetadata(),
+    [Campaign.RADIANT]: new RadiantMetadata(),
+    [Campaign.DOLOMITE]: new DolomiteMetadata(),
+    [Campaign.BADGER]: new BadgerMetadata(),
+    [Campaign.AJNA]: new AjnaMetadata(),
+    [Campaign.EULER]: new EulerMetadata(),
+    [Campaign.COMPOUND]: new CompoundMetadata(),
+    [Campaign.ION]: new IonMetadata(),
+    [Campaign.MORPHO]: new MorphoMetadata(),
+    [Campaign.HYPERDRIVELOGFIXPROCESSOR]: new HyperdriveMetadata(),
+    [Campaign.HYPERDRIVELOGPROCESSOR]: new HyperdriveMetadata(),
+    [Campaign.ERC20_FIX_APR]: new Erc20Metadata(),
+    [Campaign.UNISWAP_V4]: new UniswapV4Metadata(),
+    [Campaign.EIGENLAYER]: new EigenLayerMetadata(),
+    [Campaign.VEST]: new VestMetadata(),
+    [Campaign.ERC20LOGPROCESSOR]: new Erc20Metadata(),
+    [Campaign.ERC20REBASELOGPROCESSOR]: new Erc20Metadata(),
+    [Campaign.ERC20TRANSFERS]: new DefaultMetadata(), // TODO
+    [Campaign.M0]: new DefaultMetadata(), // TODO
+    [Campaign.MORPHOSUPPLY]: new DefaultMetadata(), // TODO
+    [Campaign.SYNCSWAP_VAULT]: new DefaultMetadata(), // TODO
+    [Campaign.AMBIENTPROCESSOR]: new AmbientMetadata(),
+    [Campaign.ENCOMPASSING]: new EncompassingMetadata(),
+    [Campaign.EVENT_BASED]: new EventBasedMetadata(),
+    [Campaign.ERC20REBASEFIXAPR]: new Erc20Metadata(),
+};
+export const metadataBuilderFactory = (campaignType) => map[campaignType];

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

@@ -0,0 +1,15 @@
+import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.AJNA;
+export declare class AjnaMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        action: "LEND" | "BORROW";
+        name: string;
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,52 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { OpportunityAction } from "@db/api";
+export class AjnaMetadata {
+    async build(computeChainId, params, subType) {
+        try {
+            const [collateral, quote] = await TokenService.findManyOrCreate([
+                {
+                    chainId: computeChainId,
+                    address: params.collateralToken,
+                },
+                {
+                    chainId: computeChainId,
+                    address: params.quoteToken,
+                },
+            ]);
+            if (!collateral || !quote)
+                throw new Error("Failed to fetch tokens");
+            const market = `${params.symbolQuoteToken}/${collateral?.symbol}`;
+            const subtypes = [
+                { name: `Supply ${collateral?.symbol} on ${market}`, action: OpportunityAction.LEND },
+                { name: `Borrow ${quote?.symbol} on ${market}`, action: OpportunityAction.BORROW },
+            ];
+            const subtype = subtypes[subType];
+            return {
+                action: subtype.action,
+                name: subtype.name,
+                tokens: [
+                    { chainId: computeChainId, address: collateral.address },
+                    { chainId: computeChainId, address: quote.address },
+                ],
+                mainProtocol: "ajna",
+            };
+        }
+        catch (_err) {
+            const market = `${params.symbolQuoteToken}/${params.symbolCollateralToken}`;
+            const subtypes = [
+                { name: `Supply ${params.symbolCollateralToken} on ${market}`, action: OpportunityAction.LEND },
+                { name: `Borrow ${params.symbolQuoteToken} on ${market}`, action: OpportunityAction.BORROW },
+            ];
+            const subtype = subtypes[subType];
+            return {
+                action: subtype.action,
+                name: subtype.name,
+                tokens: [
+                    { chainId: computeChainId, address: params.collateralToken },
+                    { chainId: computeChainId, address: params.quoteToken },
+                ],
+                mainProtocol: "ajna",
+            };
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { type Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import type { MetadataBuilder } from "../interface";
+type campaignType = CampaignEnum.AMBIENTPROCESSOR;
+export declare class AmbientMetadata implements MetadataBuilder<campaignType> {
+    build(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], _subType: CampaignParameters<campaignType>["campaignSubType"]): Promise<{
+        name: string;
+        action: "POOL";
+        tokens: {
+            chainId: ChainId;
+            address: any;
+        }[];
+        mainProtocol: string;
+    }>;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { OpportunityAction } from "@db/api";
+import { almName, } from "@sdk";
+import { getAddress } from "viem";
+export class AmbientMetadata {
+    async build(computeChainId, params, _subType) {
+        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",
+        };
+    }
+}

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

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

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

@@ -0,0 +1,25 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { OpportunityAction } from "@db/api";
+export class BadgerMetadata {
+    async build(computeChainId, params) {
+        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",
+            };
+        }
+        catch {
+            return {
+                action: OpportunityAction.BORROW,
+                name: `Borrow ${params.symbolTargetToken}`,
+                tokens: [{ chainId: computeChainId, address: params.targetToken }],
+                mainProtocol: "badger",
+            };
+        }
+    }
+}

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

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