@merkl/api 0.9.15

package/dist/src/modules/v4/kyberzap/kyberzap.model.js

@@ -0,0 +1,83 @@
+import { ChainId } from "@sdk";
+import { t } from "elysia";
+export const dexIdToProtocolId = {
+    DEX_UNISWAPV3: "uniswap",
+    DEX_UNISWAPV2: "uniswap",
+    DEX_PANCAKESWAPV3: "pancakeswap",
+    DEX_SUSHISWAPV3: "sushiswap",
+    DEX_CURVE: "curve",
+    DEX_SYNCSWAP_V3: "syncswap",
+    // DEX_SYNCSWAP_V1_V2: "syncswap",
+    DEX_ZKSWAP_V3: "zkswap",
+    DEX_QUICKSWAPV3UNI: "quickswap",
+    DEX_QUICKSWAPV3ALGEBRA: "quickswap",
+    DEX_THRUSTERV3: "thruster",
+    DEX_CAMELOTV3: "camelot",
+    DEX_BEEFY: "beefy",
+    DEX_KOICL: "koi",
+    DEX_AERODROMECL: "aerodrome",
+    DEX_BALANCER: "balancer",
+};
+export const chainToKyberLabel = {
+    [ChainId.ARBITRUM]: "arbitrum",
+    [ChainId.AVALANCHE]: "avalance",
+    [ChainId.BASE]: "base",
+    [ChainId.BLAST]: "blast",
+    [ChainId.BSC]: "bsc",
+    [ChainId.MAINNET]: "ethereum",
+    [ChainId.LINEA]: "linea",
+    [ChainId.OPTIMISM]: "optimism",
+    [ChainId.POLYGON]: "polygon",
+    [ChainId.POLYGONZKEVM]: "polygon-zkevm",
+    [ChainId.SCROLL]: "scroll",
+    [ChainId.ZKSYNC]: "zksync",
+};
+export const apiTypes = {
+    "/api/v1/in/route": {
+        query: t.Object({
+            dex: t.String({ example: "DEX_UNISWAPV3" }),
+            "pool.id": t.String({ example: "0x2f5e87c9312fa29aed5c179e456625d79015299c" }),
+            "position.tickLower": t.String(),
+            "position.tickUpper": t.String(),
+            tokenIn: t.String(),
+            amountIn: t.String(),
+            feeAddress: t.Optional(t.String()),
+            feePcm: t.Optional(t.Number()),
+            slippage: t.Optional(t.Number()),
+        }),
+        response: t.Object({
+            message: t.String({ example: "OK" }),
+            data: t.Object({
+                poolDetails: t.Object({}),
+                positionDetails: t.Object({}),
+                zapDetails: t.Object({
+                    actions: t.Array(t.Object({}, { description: "ZapActions" })),
+                    finalAmountUsd: t.String(),
+                    priceImpact: t.Number(),
+                }),
+                route: t.String(),
+                routerAddress: t.String(),
+            }),
+            requestId: t.String(),
+        }),
+    },
+    "/api/v1/in/route/build": {
+        query: t.Object({}),
+        body: t.Object({
+            sender: t.String(),
+            recipient: t.String(),
+            route: t.String(),
+            deadline: t.Number(),
+            source: t.String(),
+        }),
+        response: t.Object({
+            message: t.String({ example: "OK" }),
+            data: t.Object({
+                routerAddress: t.String(),
+                callData: t.String(),
+                value: t.String(),
+            }),
+            requestId: t.String(),
+        }),
+    },
+};

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

@@ -0,0 +1,34 @@
+import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
+import type { InteractionAction, Router } from "../interaction/interaction.model";
+import { type KyberZapDexId, type ZapAction } from "./kyberzap.model";
+export declare abstract class KyberZapService {
+    #private;
+    static getDexId(protocolId: ProtocolId | string): KyberZapDexId | undefined;
+    static getChainLabel(chainId: number): string | undefined;
+    static getProtocolId(dexId: KyberZapDexId | string): ProtocolId | undefined;
+    /**
+     * @notice We don't handle tick setting in the UI for now, until we do this give the full-range ticks
+     * @param param0
+     */
+    static getFullRangeTicks(): number[];
+    /**
+     * Converts the breakdown of actions
+     * @param zapActions
+     * @returns provider-agnostic interaction actions
+     */
+    static getActions(chainId: number, zapActions: ZapAction[]): Promise<InteractionAction[]>;
+    static getTransaction(chainId: number, protocol: ProtocolId, identifier: string, userAddress: string, fromTokenAddress: string, fromTokenAmount: bigint, slippage?: number): Promise<{
+        actions: InteractionAction[];
+        depositValue: number;
+        transaction: {
+            to: string;
+            data: string;
+            value: string;
+        };
+    }>;
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter(): Router;
+}

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

@@ -0,0 +1,176 @@
+import { TokenService } from "@/modules/v4/token/token.service";
+import { chainToKyberLabel, dexIdToProtocolId, } from "./kyberzap.model";
+const KYBERZAP = "https://zap-api.kyberswap.com/";
+export class KyberZapService {
+    static async #fetch(route, params) {
+        const res = await fetch(`${KYBERZAP}${chainToKyberLabel[params?.chainId] ?? ""}${route}?${params?.query ? new URLSearchParams(params?.query) : ""}`, {
+            headers: new Headers({
+                Authorization: `Bearer ${process.env.KYBERSWAP_ZAP_API_KEY}`,
+                "Content-Type": "application/json",
+                "X-Client-Id": "merkl",
+            }),
+        });
+        if (res.status !== 200)
+            throw new Error((await res.json())?.message);
+        return (await res.json());
+    }
+    static async #post(route, params) {
+        const res = await fetch(`${KYBERZAP}${chainToKyberLabel[params?.chainId] ?? ""}${route}`, {
+            method: "POST",
+            body: JSON.stringify(params?.body),
+            headers: new Headers({
+                Authorization: `Bearer ${process.env.KYBERSWAP_ZAP_API_KEY}`,
+                "Content-Type": "application/json",
+                "X-Client-Id": "merkl",
+            }),
+        });
+        if (res.status !== 200)
+            throw new Error((await res.json())?.message);
+        return (await res.json());
+    }
+    static getDexId(protocolId) {
+        const dexId = Object.entries(dexIdToProtocolId).find(([_, id]) => id === protocolId)?.[0];
+        return dexId;
+    }
+    static getChainLabel(chainId) {
+        return chainToKyberLabel?.[chainId];
+    }
+    static getProtocolId(dexId) {
+        return dexIdToProtocolId[dexId];
+    }
+    /**
+     * @notice We don't handle tick setting in the UI for now, until we do this give the full-range ticks
+     * @param param0
+     */
+    static getFullRangeTicks() {
+        return [-886800, 886800];
+    }
+    /**
+     * Converts the breakdown of actions
+     * @param zapActions
+     * @returns provider-agnostic interaction actions
+     */
+    static async getActions(chainId, zapActions) {
+        const actions = [];
+        const processors = {
+            ACTION_TYPE_PROTOCOL_FEE: async ({ protocolFee: { tokens: zapTokens } }) => {
+                const tokens = await TokenService.findManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                return [
+                    {
+                        action: "fee",
+                        tokens: tokens.filter(t => !!t).map((t, i) => ({ ...t, amount: BigInt(zapTokens[i].amount) })),
+                    },
+                ];
+            },
+            ACTION_TYPE_AGGREGATOR_SWAP: async ({ aggregatorSwap: { swaps } }) => {
+                const swapActions = [];
+                for (const { tokenIn, tokenOut } of swaps) {
+                    const [from, to] = await TokenService.findManyOrCreate([
+                        { address: tokenIn.address, chainId },
+                        { address: tokenOut.address, chainId },
+                    ]);
+                    swapActions.push({
+                        action: "swap",
+                        from: { ...from, amount: BigInt(tokenIn.amount) },
+                        to: { ...to, amount: BigInt(tokenOut.amount) },
+                    });
+                }
+                return swapActions;
+            },
+            ACTION_TYPE_POOL_SWAP: async ({ poolSwap: { swaps } }) => {
+                const swapActions = [];
+                for (const { tokenIn, tokenOut } of swaps) {
+                    const [from, to] = await TokenService.findManyOrCreate([
+                        { address: tokenIn.address, chainId },
+                        { address: tokenOut.address, chainId },
+                    ]);
+                    swapActions.push({
+                        action: "swap",
+                        from: { ...from, amount: BigInt(tokenIn.amount) },
+                        to: { ...to, amount: BigInt(tokenOut.amount) },
+                    });
+                }
+                return swapActions;
+            },
+            ACTION_TYPE_ADD_LIQUIDITY: async ({ addLiquidity: { tokens: zapTokens } }) => {
+                const tokens = await TokenService.findManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                return [
+                    {
+                        action: "deposit",
+                        tokens: tokens.filter(t => !!t).map((t, i) => ({ ...t, amount: BigInt(zapTokens[i].amount) })),
+                    },
+                ];
+            },
+        };
+        for (const { type, ...zapAction } of zapActions) {
+            const action = await processors[type](zapAction);
+            actions.push(...action);
+        }
+        return actions;
+    }
+    static async getTransaction(chainId, protocol, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage) {
+        const [lower, upper] = KyberZapService.getFullRangeTicks();
+        const { data: route } = await KyberZapService.#fetch("/api/v1/in/route", {
+            query: {
+                tokenIn: fromTokenAddress,
+                amountIn: fromTokenAmount?.toString(),
+                "pool.id": identifier,
+                "position.tickLower": lower?.toString(),
+                "position.tickUpper": upper?.toString(),
+                dex: KyberZapService.getDexId(protocol),
+                //TODO: add a lesser value here (2% by default)
+                slippage: slippage ?? 200,
+            },
+            chainId,
+        });
+        const actions = await KyberZapService.getActions(chainId, route.zapDetails.actions);
+        const [tokenIn] = await TokenService.findManyOrCreate([{ address: fromTokenAddress, chainId }]);
+        const deposit = actions.findLast(({ action }) => action === "deposit");
+        const tokenInValue = await TokenService.getValue([{ ...tokenIn, amount: fromTokenAmount }]);
+        const depositValue = await TokenService.getValue(deposit.tokens);
+        const { data: transaction } = await KyberZapService.#post("/api/v1/in/route/build", {
+            query: {},
+            body: {
+                //TODO: add a more relevant value here
+                deadline: 1800000000,
+                recipient: userAddress,
+                sender: userAddress,
+                route: route.route,
+                source: "merkl",
+            },
+            chainId,
+        });
+        return {
+            actions,
+            depositValue,
+            transaction: {
+                to: transaction.routerAddress,
+                data: transaction.callData,
+                value: transaction.value,
+            },
+        };
+    }
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter() {
+        return {
+            name: "zap",
+            async getTarget(chainId, protocolId, identifier) {
+                const dexId = KyberZapService.getDexId(protocolId);
+                const chainLabel = KyberZapService.getChainLabel(chainId);
+                if (!dexId || !chainLabel)
+                    return;
+                return {
+                    provider: "zap",
+                    chainId: chainId,
+                    identifier: identifier,
+                };
+            },
+            async getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, options) {
+                return await KyberZapService.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, options.slippage);
+            },
+        };
+    }
+}

package/dist/src/modules/v4/liquidity/implementations/AjnaPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher } from "../liquidity.model";
+export declare class AjnaPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<import("../liquidity.model").PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/AjnaPositionFetcher.js

@@ -0,0 +1,90 @@
+import { AjnaSubCampaignType, BN2Number, Campaign, ChainInteractionService, NETWORK_LABELS, POOL_INFO_UTILS, PoolInfoUtilsInterface, } from "@sdk";
+import axios from "axios";
+import { CampaignService } from "../../campaign";
+const campaignType = Campaign.AJNA;
+export class AjnaPositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId && !!o?.campaigns?.length);
+        const calls = [];
+        for (const opportunity of opportunities) {
+            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            // Call per opportunity
+            if (campaign.campaignSubType === AjnaSubCampaignType.lend) {
+                calls.push({
+                    allowFailure: true,
+                    callData: PoolInfoUtilsInterface.encodeFunctionData("poolPricesInfo", [campaign.campaignParameters.poolId]),
+                    target: POOL_INFO_UTILS[chainId],
+                });
+            }
+            else {
+                calls.push({
+                    allowFailure: true,
+                    callData: PoolInfoUtilsInterface.encodeFunctionData("borrowerInfo", [
+                        campaign.campaignParameters.poolId,
+                        user,
+                    ]),
+                    target: POOL_INFO_UTILS[chainId],
+                });
+            }
+        }
+        const res = await ChainInteractionService(chainId).fetchState(calls);
+        const result = [];
+        for (const [index, opportunity] of opportunities.entries()) {
+            // Decoding per opportunity
+            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            let userSupply = 0;
+            // @Lamicham it's not scalable at all to do this.. We do 1 call per opportunity, sequentially, so it ends up
+            // slowing the whole position route
+            const resAjna = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/wallets/${user.toLowerCase()}/pools/${campaign.campaignParameters.poolId.toLowerCase()}/buckets/?p=1&p_size=50`);
+            if (resAjna.data.count === 0) {
+                continue;
+            }
+            if (campaign.campaignSubType === AjnaSubCampaignType.lend) {
+                const htpIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", res[index].returnData)[3];
+                const lupIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", res[index].returnData)[5];
+                const threshold = BN2Number(BN2Number(lupIndex, 0) === 0 ? lupIndex : lupIndex.gt(htpIndex) ? lupIndex.add(22) : htpIndex.add(22), 0);
+                let nextRoute = null;
+                if (!!resAjna.data.next) {
+                    nextRoute = `https://${resAjna.data.next.slice(resAjna.data.next.indexOf(":") + 1)}`;
+                }
+                let position;
+                for (position of resAjna.data.results) {
+                    if (position.bucket_index < threshold) {
+                        userSupply += Number(position.deposit);
+                    }
+                }
+                while (nextRoute !== null) {
+                    const resNext = await axios.get(nextRoute);
+                    let position;
+                    for (position of resNext.data.results) {
+                        if (position.bucket_index < threshold) {
+                            userSupply += Number(position.deposit);
+                        }
+                    }
+                    if (!!resNext.data.next) {
+                        nextRoute = `https://${resNext.data.next.slice(resNext.data.next.indexOf(":") + 1)}`;
+                    }
+                    else {
+                        nextRoute = null;
+                    }
+                }
+            }
+            else {
+                userSupply = BN2Number(PoolInfoUtilsInterface.decodeFunctionResult("borrowerInfo", res[index].returnData)[0], 18);
+            }
+            if (userSupply > 0) {
+                result.push({
+                    flags: {},
+                    opportunity,
+                    tokens: [
+                        {
+                            token: opportunity.tokens.find(t => t.address === campaign.campaignParameters.quoteToken),
+                            breakdown: [{ type: "balance", value: userSupply }],
+                        },
+                    ],
+                });
+            }
+        }
+        return result;
+    };
+}

package/dist/src/modules/v4/liquidity/implementations/BadgerPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class BadgerPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/BadgerPositionFetcher.js

@@ -0,0 +1,69 @@
+import { CDPMANAGER_ADDRESS, SORTEDCDPS_ADDRESS } from "@/constants";
+import { BN2Number, Campaign, CdpManagerInterface, ChainInteractionService, ERC20Interface, SortedCdpsInterface, } from "@sdk";
+import { CampaignService } from "../../campaign";
+const campaignType = Campaign.BADGER;
+export class BadgerPositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
+        const calls = [];
+        calls.push({
+            allowFailure: false,
+            callData: CdpManagerInterface.encodeFunctionData("getSystemDebt"),
+            target: CDPMANAGER_ADDRESS,
+        });
+        for (const opportunity of opportunities) {
+            // Call per opportunity
+            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            calls.push({
+                allowFailure: false,
+                callData: SortedCdpsInterface.encodeFunctionData("getCdpsOf", [user]),
+                target: SORTEDCDPS_ADDRESS,
+            });
+            for (const _token of opportunity.tokens) {
+                // Call per token
+            }
+        }
+        const res = await ChainInteractionService(chainId).fetchState(calls);
+        const result = [];
+        let i = 0;
+        const totalSupplyEBTC = BN2Number(CdpManagerInterface.decodeFunctionResult("getSystemDebt", res[i++].returnData)[0], 18);
+        for (const [index, opportunity] of opportunities.entries()) {
+            // Decoding per opportunity
+            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            let userSupply = 0;
+            const cdps = SortedCdpsInterface.decodeFunctionResult("getCdpsOf", res[i++].returnData)[0];
+            if (cdps.length !== 0) {
+                const secondCalls = cdps.map((cdp) => {
+                    return {
+                        allowFailure: false,
+                        callData: CdpManagerInterface.encodeFunctionData("Cdps", cdp),
+                        target: CDPMANAGER_ADDRESS,
+                    };
+                });
+                const secondRes = await ChainInteractionService(chainId).fetchState(secondCalls);
+                cdps.forEach((cdp, j) => {
+                    const cdpSupply = CdpManagerInterface.decodeFunctionResult("Cdps", secondRes[j].returnData)[0];
+                    userSupply += BN2Number(cdpSupply, campaign.campaignParameters.decimalsTargetToken);
+                });
+            }
+            for (const [subIndex, token] of opportunity.tokens.entries()) {
+                // Decoding per token
+                const balance = ERC20Interface.decodeFunctionResult("balanceOf", res[index + subIndex].returnData)[0].toString();
+                if (BigInt(balance) > 0n) {
+                    const position = {
+                        flags: {},
+                        opportunity,
+                        tokens: [
+                            {
+                                token,
+                                breakdown: [{ type: "balance", value: BN2Number(balance, token.decimals) }],
+                            },
+                        ],
+                    };
+                    result.push(position);
+                }
+            }
+        }
+        return result;
+    };
+}

package/dist/src/modules/v4/liquidity/implementations/ClammPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class ClammPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/ClammPositionFetcher.js

@@ -0,0 +1,61 @@
+import { getClammUserPositions } from "@/libs/positions/clamm";
+import { Campaign } from "@sdk";
+import { CampaignService } from "../../campaign";
+const campaignType = Campaign.CLAMM;
+export class ClammPositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
+        // AMM => pool address => pool data
+        const poolsByAmm = {};
+        for (const opportunity of opportunities) {
+            // Call per opportunity
+            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            if (!poolsByAmm[campaign.campaignParameters.amm]) {
+                poolsByAmm[campaign.campaignParameters.amm] = {};
+            }
+            if (!poolsByAmm[campaign.campaignParameters.amm][campaign.campaignParameters.poolAddress]) {
+                poolsByAmm[campaign.campaignParameters.amm][campaign.campaignParameters.poolAddress] = {
+                    token0: campaign.campaignParameters.token0,
+                    token1: campaign.campaignParameters.token1,
+                    symbolToken0: campaign.campaignParameters.symbolToken0,
+                    symbolToken1: campaign.campaignParameters.symbolToken1,
+                    decimalsToken0: campaign.campaignParameters.decimalsToken0,
+                    decimalsToken1: campaign.campaignParameters.decimalsToken1,
+                    mainParameter: campaign.mainParameter,
+                    forwarders: {},
+                };
+            }
+        }
+        const clammPositions = await getClammUserPositions(user, chainId, poolsByAmm, false);
+        const result = [];
+        for (const opportunity of opportunities) {
+            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            const clammPosition = clammPositions[`2_${campaign.campaignParameters.poolAddress}`];
+            const poolData = poolsByAmm[campaign.campaignParameters.amm][campaign.campaignParameters.poolAddress];
+            if (!!clammPosition) {
+                const position = {
+                    flags: {},
+                    opportunity,
+                    tokens: [
+                        {
+                            token: opportunity.tokens.filter(t => t.address === poolData.token0)?.[0],
+                            breakdown: [
+                                { type: "balance", value: clammPosition.userBalanceToken0 },
+                                { type: "liquidity", value: clammPosition.userInRangeLiquidity },
+                            ],
+                        },
+                        {
+                            token: opportunity.tokens.filter(t => t.address === poolData.token1)?.[0],
+                            breakdown: [
+                                { type: "balance", value: clammPosition.userBalanceToken1 },
+                                { type: "liquidity", value: clammPosition.userInRangeLiquidity },
+                            ],
+                        },
+                    ],
+                };
+                result.push(position);
+            }
+        }
+        return result;
+    };
+}

package/dist/src/modules/v4/liquidity/implementations/DolomitePositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher } from "../liquidity.model";
+export declare class DolomitePositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<import("../liquidity.model").PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/DolomitePositionFetcher.js

@@ -0,0 +1,45 @@
+import { Campaign } from "@sdk";
+import { utils } from "ethers";
+import { CampaignService } from "../../campaign";
+import { LiquidityRepository } from "../liquidity.repository";
+const campaignType = Campaign.DOLOMITE;
+export class DolomitePositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
+        const dolomitePositions = await LiquidityRepository.findManyDolomitePositions(chainId, user);
+        // Generic calls
+        for (const opportunity of opportunities) {
+            // Call per opportunity
+            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            for (const _token of opportunity.tokens) {
+                // Call per token
+            }
+        }
+        const result = [];
+        // Decoding Generic calls
+        for (const [_index, opportunity] of opportunities.entries()) {
+            const campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            // Decoding per opportunity
+            const positionIndex = dolomitePositions.findIndex(y => utils.getAddress(y.token.id) === campaign.campaignParameters.targetToken);
+            const position = positionIndex >= 0 ? dolomitePositions[positionIndex] : undefined;
+            if (!position)
+                continue;
+            const borrowBalance = Number.parseFloat(position.token.borrowLiquidity);
+            const supplyBalance = Number.parseFloat(position.token.supplyLiquidity);
+            result.push({
+                flags: {},
+                opportunity,
+                tokens: [
+                    {
+                        token: opportunity.tokens.find(t => utils.getAddress(t.address) === campaign.campaignParameters.targetToken),
+                        breakdown: [
+                            { type: "borrowed", value: borrowBalance },
+                            { type: "supplied", value: supplyBalance },
+                        ],
+                    },
+                ],
+            });
+        }
+        return result;
+    };
+}

package/dist/src/modules/v4/liquidity/implementations/ERC20PositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class ERC20PositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

package/dist/src/modules/v4/liquidity/implementations/ERC20PositionFetcher.js

@@ -0,0 +1,47 @@
+import { BN2Number, Campaign, ChainInteractionService, ERC20Interface } from "@sdk";
+import { CampaignService } from "../../campaign";
+const campaignType = Campaign.ERC20;
+export class ERC20PositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
+        const calls = [];
+        // Generic calls
+        for (const opportunity of opportunities) {
+            // Call per opportunity
+            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            for (const token of opportunity.tokens) {
+                // Call per token
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
+                    target: token.address,
+                });
+            }
+        }
+        const res = await ChainInteractionService(chainId).fetchState(calls);
+        const result = [];
+        // Decoding Generic calls
+        for (const [index, opportunity] of opportunities.entries()) {
+            // Decoding per opportunity
+            const _campaign = CampaignService.formatAsCampaignParameters(opportunity.campaigns[0]);
+            for (const [subIndex, token] of opportunity.tokens.entries()) {
+                // Decoding per token
+                const balance = ERC20Interface.decodeFunctionResult("balanceOf", res[index + subIndex].returnData)[0].toString();
+                if (BigInt(balance) > 0n) {
+                    const position = {
+                        flags: {},
+                        opportunity,
+                        tokens: [
+                            {
+                                token,
+                                breakdown: [{ type: "balance", value: BN2Number(balance, token.decimals) }],
+                            },
+                        ],
+                    };
+                    result.push(position);
+                }
+            }
+        }
+        return result;
+    };
+}

package/dist/src/modules/v4/liquidity/implementations/EulerPositionFetcher.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { Opportunity } from "../../opportunity";
+import type { PositionFetcher, PositionT } from "../liquidity.model";
+export declare class EulerPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}