@merkl/api 0.21.47 → 1.0.0

package/dist/src/modules/v4/explorer/explorer.controller.js

@@ -1,13 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import Elysia from "elysia";
-import { CreateExplorerDto } from "./explorer.model";
-import { ExplorerService } from "./explorer.service";
-// ─── Explorer Controller ───────────────────────────────────────────────────────
-export const ExplorerController = new Elysia({ prefix: "/explorers", detail: { tags: ["Explorers"] } })
-    // ─── Create An Explorer ──────────────────────────────────────────────────────
-    .post("", async ({ body }) => await ExplorerService.create(body), {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    body: CreateExplorerDto,
-    detail: { hide: true },
-});

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

@@ -1,8 +0,0 @@
-// ─── Schemas ─────────────────────────────────────────────────────────────────
-import { ExplorerType } from "@db/api";
-import { t } from "elysia";
-export const CreateExplorerDto = t.Object({
-    chainId: t.Numeric(),
-    type: t.Enum(ExplorerType),
-    url: t.String(),
-});

package/dist/src/modules/v4/explorer/explorer.repository.js

@@ -1,23 +0,0 @@
-import { apiDbClient } from "@db";
-import { ExplorerService } from "./explorer.service";
-export class ExplorerRepository {
-    static async getByChainId(chainId) {
-        return await apiDbClient.explorer.findFirstOrThrow({ where: { chainId } });
-    }
-    /**
-     * Creates an explorer
-     * @param chainId to attach explorer to
-     * @param type that defines the subsequents links for transactions, addresses...
-     * @param url base url without / suffix
-     */
-    static async create(chainId, type, url) {
-        return apiDbClient.explorer.create({
-            data: {
-                chainId,
-                type,
-                url,
-                id: ExplorerService.hashId(type, chainId),
-            },
-        });
-    }
-}

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

@@ -1,24 +0,0 @@
-import { ExplorerRepository } from "./explorer.repository";
-export class ExplorerService {
-    static hashId(type, chainId) {
-        return Bun.hash(`${type}${chainId}`).toString();
-    }
-    static async getByChainId(chainId) {
-        return await ExplorerRepository.getByChainId(chainId);
-    }
-    static format(explorer) {
-        const { id, ...rest } = explorer;
-        return {
-            ...rest,
-        };
-    }
-    /**
-     * Creates an explorer
-     * @param chainId to attach explorer to
-     * @param type that defines the subsequents links for transactions, addresses...
-     * @param url base url without / suffix
-     */
-    static async create(data) {
-        return ExplorerRepository.create(data.chainId, data.type, data.url);
-    }
-}

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,16 +0,0 @@
-export class IconService {
-    static async pullPush(url, bucket, metadata) {
-        const filename = metadata?.name ?? url;
-        const iconFile = await fetch(url);
-        const mimeType = iconFile.headers.get("content-type");
-        const extension = metadata?.extension ? metadata.extension : mimeType.split("/")[1].split("+")[0];
-        const byteArray = await iconFile.bytes();
-        await bucket.pushRaw(`${filename}.${extension}`, byteArray, {
-            type: mimeType,
-            isPublic: true,
-            compression: true,
-            overwrite: true,
-        });
-        return `${process.env.GCS_ENDPOINT}/${bucket.getBucketName()}/${filename}.${extension}`;
-    }
-}

package/dist/src/modules/v4/interaction/interaction.controller.js

@@ -1,45 +0,0 @@
-import Elysia from "elysia";
-import { isAddress } from "viem";
-import { EnsoService } from "../enso/enso.service";
-import { GetInteractionProtocolsQueryDto, GetInteractionQuoteQueryDto, GetInteractionTargetsQueryDto, } from "./interaction.model";
-import { InteractionService } from "./interaction.service";
-// ─── Interaction Controller ──────────────────────────────────────────────────
-export const InteractionController = new Elysia({
-    prefix: "/interaction",
-    detail: { tags: ["Interaction"], hide: true },
-})
-    .get("/targets", async ({ query: { protocolId, chainId, identifier } }) => {
-    if (!isAddress(identifier))
-        return [];
-    return await InteractionService.getTargets(chainId, protocolId, identifier);
-}, {
-    query: GetInteractionTargetsQueryDto,
-    detail: {
-        summary: "Available interaction targets for a protocol",
-        description: "Retrieves all the pool/token/contract",
-    },
-})
-    // ─── Get All Compatible Protocols ───────────────────────────────────────
-    .get("/protocols", async ({ query }) => await EnsoService.getCompatibleProtocols(query), {
-    query: GetInteractionProtocolsQueryDto,
-    detail: {
-        summary: "Interactable protocols",
-        description: "Retrieves protocols integrated by merkl which supports being interacted with",
-    },
-})
-    // ─── Get Transaction ─────────────────────────────────────────────────
-    .get("/transaction", async ({ query: { protocolId, chainId, identifier, userAddress, fromAmount, fromTokenAddress, slippage } }) => {
-    if (!isAddress(identifier))
-        return;
-    const [target] = await InteractionService.getTargets(chainId, protocolId, identifier);
-    //TODO: throw error
-    if (!target)
-        return;
-    return await InteractionService.getTransaction(target.provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, BigInt(fromAmount), slippage);
-}, {
-    query: GetInteractionQuoteQueryDto,
-    detail: {
-        summary: "Get participate transaction",
-        description: "",
-    },
-});

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

@@ -1,25 +0,0 @@
-import { t } from "elysia";
-import { protocolIdList } from "../protocol/protocol.model";
-export const participateInputTypes = ["tokenAmount", "token"];
-export const participateTypes = ["link", "deposit", "withdraw"];
-export const GetInteractionTargetsQueryDto = t.Object({
-    chainId: t.Numeric(),
-    protocolId: t.Optional(t.String({
-        examples: protocolIdList.join(", "),
-    })),
-    identifier: t.String(),
-});
-export const GetInteractionQuoteQueryDto = t.Object({
-    chainId: t.Numeric(),
-    protocolId: t.String({
-        examples: protocolIdList.join(", "),
-    }),
-    identifier: t.String(),
-    userAddress: t.String(),
-    fromTokenAddress: t.String(),
-    fromAmount: t.String(),
-    slippage: t.Optional(t.Number({ description: "Slippage in basis points (O.1%)" })),
-});
-export const GetInteractionProtocolsQueryDto = t.Object({
-    chainId: t.Optional(t.Numeric()),
-});

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

@@ -1,95 +0,0 @@
-import { ChainInteractionService } from "@/modules/v4/chainInteraction/chainInteraction.service";
-import { EnsoService } from "@/modules/v4/enso/enso.service";
-import { KyberZapService } from "@/modules/v4/kyberzap/kyberzap.service";
-import { ETH_ADDRESS, ETH_ZKSYNC_ADDRESS } from "@sdk";
-import { decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
-export class InteractionService {
-    static routers = [KyberZapService, EnsoService].map(service => service.getRouter());
-    /**
-     * Returns a target entry for each router, indicating the possiblity to deposit
-     * @param chainId compute
-     * @param protocolId i.e. "aave", "venus"
-     * @param identifier i.e. mainParameter, poolAddress
-     * @returns information about available routers
-     */
-    static async getTargets(chainId, protocolId, identifier) {
-        return (await Promise.all(InteractionService.routers?.map(router => router.getTarget(chainId, protocolId, identifier)))).filter(a => a !== undefined);
-    }
-    /**
-     * Gets transaction to interact on opportunity via a router
-     * @param provider i.e. "enso" or "zap"
-     * @param chainId compute
-     * @param protocolId i.e. "aave", "venus"
-     * @param identifier i.e. mainParameter, poolAddress
-     * @param userAddress
-     * @param fromTokenAddress
-     * @param fromTokenAmount
-     * @param slippage
-     * @returns transaction and approval state
-     */
-    static async getTransaction(provider, chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage) {
-        const router = InteractionService.routers.find(({ name }) => name === provider);
-        if (!router)
-            throw new Error(`Router "${provider} not found`);
-        // Normalizing ETH on ZKSync
-        if (fromTokenAddress === ETH_ZKSYNC_ADDRESS)
-            fromTokenAddress = ETH_ADDRESS;
-        const transaction = await router.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, { slippage });
-        const { allowance, approval, approved } = await InteractionService.getApproval(chainId, userAddress, transaction.transaction.to, fromTokenAddress, fromTokenAmount);
-        return { amountIn: fromTokenAmount, ...transaction, allowance, approval, approved };
-    }
-    /**
-     * Gets approval information onchain
-     * @returns approved?, approval tx & allowance amount
-     */
-    static async getApproval(chainId, owner, spender, tokenAddress, amount) {
-        // Normalizing ETH on ZKSync
-        if (tokenAddress === ETH_ZKSYNC_ADDRESS)
-            tokenAddress = ETH_ADDRESS;
-        //TODO: add utils to make using viem type-safety more concise
-        const abi = parseAbi([
-            "function approve(address, uint256) returns (bool)",
-            "function allowance(address owner, address spender) returns (uint256)",
-        ]);
-        if (tokenAddress === ETH_ADDRESS)
-            return {
-                approved: true,
-                allowance: 0n,
-                approval: {
-                    to: tokenAddress,
-                    data: encodeFunctionData({
-                        abi,
-                        functionName: "approve",
-                        args: [spender, amount],
-                    }),
-                },
-            };
-        const decode = (r) => decodeFunctionResult({
-            abi,
-            functionName: "allowance",
-            data: r?.returnData,
-        });
-        const allowance = await ChainInteractionService(chainId).fetchAndDecode({
-            target: tokenAddress,
-            allowFailure: true,
-            callData: encodeFunctionData({
-                abi,
-                functionName: "allowance",
-                args: [owner, spender],
-            }),
-        }, decode);
-        const approved = allowance >= amount;
-        return {
-            approved,
-            allowance,
-            approval: {
-                to: tokenAddress,
-                data: encodeFunctionData({
-                    abi,
-                    functionName: "approve",
-                    args: [spender, amount],
-                }),
-            },
-        };
-    }
-}

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

@@ -1,83 +0,0 @@
-import { ChainId } from "@sdk";
-import { t } from "elysia";
-export const dexIdToProtocolId = {
-    DEX_UNISWAPV3: "uniswap",
-    DEX_UNISWAPV2: "uniswap",
-    DEX_PANCAKESWAPV3: "pancake-swap",
-    DEX_SUSHISWAPV3: "sushi-swap",
-    DEX_CURVE: "curve",
-    DEX_SYNCSWAP_V3: "syncswap",
-    // DEX_SYNCSWAP_V1_V2: "syncswap",
-    DEX_ZKSWAP_V3: "zk-swap",
-    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.js

@@ -1,176 +0,0 @@
-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.js

@@ -1,90 +0,0 @@
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { AjnaSubCampaignType, BN2Number, Campaign, ChainInteractionService, NETWORK_LABELS, POOL_INFO_UTILS, PoolInfoUtilsInterface, } from "@sdk";
-import axios from "axios";
-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;
-    };
-}