@merkl/api 0.10.168 → 0.10.170

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

@@ -1,7 +1,7 @@
 import { type CreateCampaignModel } from "../campaign";
 import { Prisma } from "../../../../database/api/.generated";
-import { type ChainId } from "@sdk";
-import type { CreateOpportunityModel, GetOpportunitiesQueryEntity, LightOpportunityFromDB, OpportunityMetadata, OpportunityUnique } from "./opportunity.model";
+import { type ChainId, type MerklChainId } from "@sdk";
+import type { CreateOpportunityModel, GetOpportunitiesQueryModel, LightOpportunityFromDB, OpportunityMetadata, OpportunityUnique } from "./opportunity.model";
 import { OpportunityRepository } from "./opportunity.repository";
 export declare abstract class OpportunityService {
     static hashId(opportunity: OpportunityUnique): string;
@@ -60,7 +60,9 @@ export declare abstract class OpportunityService {
                     address: string;
                     icon: string;
                     decimals: number;
+                    displaySymbol: string;
                     verified: boolean;
+                    isTest: boolean;
                     price: number | null;
                 };
                 amount: bigint;
@@ -75,7 +77,9 @@ export declare abstract class OpportunityService {
             address: string;
             icon: string;
             decimals: number;
+            displaySymbol: string;
             verified: boolean;
+            isTest: boolean;
             price: number | null;
         }[];
         chain: {
@@ -102,7 +106,7 @@ export declare abstract class OpportunityService {
         apr: number;
         dailyRewards: number;
     } & {
-        campaigns: ({
+        campaigns: {
             params: any;
             chain: {
                 name: string;
@@ -117,7 +121,9 @@ export declare abstract class OpportunityService {
                 address: string;
                 icon: string;
                 decimals: number;
+                displaySymbol: string;
                 verified: boolean;
+                isTest: boolean;
                 price: number | null;
             };
             distributionChain: {
@@ -145,7 +151,7 @@ export declare abstract class OpportunityService {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
-        } | null)[];
+        }[];
     }) | null>;
     static getUniqueOrThrow(opportunityId: string | OpportunityUnique): Promise<{
         aprRecord: {
@@ -188,7 +194,9 @@ export declare abstract class OpportunityService {
                     address: string;
                     icon: string;
                     decimals: number;
+                    displaySymbol: string;
                     verified: boolean;
+                    isTest: boolean;
                     price: number | null;
                 };
                 amount: bigint;
@@ -203,7 +211,9 @@ export declare abstract class OpportunityService {
             address: string;
             icon: string;
             decimals: number;
+            displaySymbol: string;
             verified: boolean;
+            isTest: boolean;
             price: number | null;
         }[];
         chain: {
@@ -235,7 +245,7 @@ export declare abstract class OpportunityService {
      * @param query
      * @returns A list of opportunities
      */
-    static getMany(query: GetOpportunitiesQueryEntity): Promise<({
+    static getMany(query: GetOpportunitiesQueryModel): Promise<({
         aprRecord: {
             cumulated: number;
             timestamp: bigint;
@@ -276,7 +286,9 @@ export declare abstract class OpportunityService {
                     address: string;
                     icon: string;
                     decimals: number;
+                    displaySymbol: string;
                     verified: boolean;
+                    isTest: boolean;
                     price: number | null;
                 };
                 amount: bigint;
@@ -291,7 +303,9 @@ export declare abstract class OpportunityService {
             address: string;
             icon: string;
             decimals: number;
+            displaySymbol: string;
             verified: boolean;
+            isTest: boolean;
             price: number | null;
         }[];
         chain: {
@@ -318,6 +332,140 @@ export declare abstract class OpportunityService {
         apr: number;
         dailyRewards: number;
     } | null)[]>;
+    static findLiveWithFirstCampaign(chainId: MerklChainId): Promise<({
+        aprRecord: {
+            cumulated: number;
+            timestamp: bigint;
+            breakdowns: {
+                type: import("../../../../database/api/.generated").$Enums.AprType;
+                id: number;
+                identifier: string;
+                value: number;
+                aprRecordId: string;
+            }[];
+        };
+        tvlRecord: {
+            id: string;
+            total: number;
+            timestamp: bigint;
+            breakdowns: {
+                type: import("../../../../database/api/.generated").$Enums.TvlType;
+                id: number;
+                identifier: string;
+                value: number;
+                tvlRecordId: string;
+            }[];
+        };
+        rewardsRecord: {
+            id: string;
+            total: number;
+            timestamp: bigint;
+            breakdowns: {
+                id: number;
+                value: number;
+                campaignId: string;
+                dailyRewardsRecordId: string;
+                token: {
+                    symbol: string;
+                    name: string | null;
+                    id: string;
+                    chainId: number;
+                    address: string;
+                    icon: string;
+                    decimals: number;
+                    displaySymbol: string;
+                    verified: boolean;
+                    isTest: boolean;
+                    price: number | null;
+                };
+                amount: bigint;
+            }[];
+        };
+        id: string;
+        tokens: {
+            symbol: string;
+            name: string | null;
+            id: string;
+            chainId: number;
+            address: string;
+            icon: string;
+            decimals: number;
+            displaySymbol: string;
+            verified: boolean;
+            isTest: boolean;
+            price: number | null;
+        }[];
+        chain: {
+            name: string;
+            id: number;
+            icon: string;
+        };
+        protocol: {
+            name: string;
+            url: string;
+            description: string;
+            id: string;
+            tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+            icon: string;
+        } | undefined;
+        name: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        status: import("../../../../database/api/.generated").$Enums.Status;
+        tags: string[];
+        identifier: string;
+        chainId: number;
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        tvl: number;
+        apr: number;
+        dailyRewards: number;
+    } & {
+        campaigns: {
+            params: any;
+            chain: {
+                name: string;
+                id: number;
+                icon: string;
+            };
+            rewardToken: {
+                symbol: string;
+                name: string | null;
+                id: string;
+                chainId: number;
+                address: string;
+                icon: string;
+                decimals: number;
+                displaySymbol: string;
+                verified: boolean;
+                isTest: boolean;
+                price: number | null;
+            };
+            distributionChain: {
+                name: string;
+                id: number;
+                icon: string;
+            } | undefined;
+            campaignStatus: {
+                error: string;
+                details: Prisma.JsonValue;
+                status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                campaignId: string;
+                computedUntil: bigint;
+                processingStarted: bigint;
+            };
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            id: string;
+            subType: number | null;
+            startTimestamp: bigint;
+            endTimestamp: bigint;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+            creatorAddress: string;
+        }[];
+    })[]>;
     static getAllIds(): Promise<{
         id: string;
     }[]>;
@@ -327,7 +475,7 @@ export declare abstract class OpportunityService {
      * @param query
      * @returns the number of opportunities
      */
-    static countMany(query: GetOpportunitiesQueryEntity): Promise<number>;
+    static countMany(query: GetOpportunitiesQueryModel): Promise<number>;
     static formatResponse(opportunity: Awaited<ReturnType<typeof OpportunityRepository.findUniqueOrThrow>>): {
         aprRecord: {
             cumulated: number;
@@ -369,7 +517,9 @@ export declare abstract class OpportunityService {
                     address: string;
                     icon: string;
                     decimals: number;
+                    displaySymbol: string;
                     verified: boolean;
+                    isTest: boolean;
                     price: number | null;
                 };
                 amount: bigint;
@@ -384,7 +534,9 @@ export declare abstract class OpportunityService {
             address: string;
             icon: string;
             decimals: number;
+            displaySymbol: string;
             verified: boolean;
+            isTest: boolean;
             price: number | null;
         }[];
         chain: {
@@ -421,7 +573,9 @@ export declare abstract class OpportunityService {
             address: string;
             icon: string;
             decimals: number;
+            displaySymbol: string;
             verified: boolean;
+            isTest: boolean;
             price: number | null;
         }[];
         chain: {
@@ -448,7 +602,7 @@ export declare abstract class OpportunityService {
         apr: number;
         dailyRewards: number;
     };
-    static aggregate(query: GetOpportunitiesQueryEntity, field: keyof Prisma.OpportunitySumAggregateInputType): Promise<{
-        sum: never;
+    static aggregate(query: GetOpportunitiesQueryModel, field: keyof Prisma.OpportunitySumAggregateInputType): Promise<{
+        sum: number | null;
     }>;
 }

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

@@ -152,6 +152,17 @@ export class OpportunityService {
             }, query);
         });
     }
+    static async findLiveWithFirstCampaign(chainId) {
+        return record("data-layer.access", async () => {
+            return await CacheService.wrap(TTLPresets.MIN_10, async (chainId) => {
+                const opportunities = await OpportunityRepository.findLiveWithFirstCampaign(chainId);
+                return opportunities.map(o => {
+                    const formatted = OpportunityService.formatResponse(o);
+                    return Object.assign(formatted, { campaigns: o.Campaigns.map(CampaignService.format) });
+                });
+            }, chainId);
+        });
+    }
     static async getAllIds() {
         return await OpportunityRepository.getAllIdsForDynamicOpp();
     }

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

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

package/dist/src/modules/v4/position/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/position/implementations/BadgerPositionFetcher.d.ts

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

package/dist/src/modules/v4/position/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/position/implementations/ClammPositionFetcher.d.ts

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

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

@@ -0,0 +1,71 @@
+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: {},
+                };
+            }
+        }
+        console.log(poolsByAmm);
+        const clammPositions = await getClammUserPositions(user, chainId, poolsByAmm, false);
+        console.log(clammPositions);
+        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: {
+                                address: poolData.token0,
+                                decimals: poolData.decimalsToken0,
+                                symbol: poolData.symbolToken0,
+                            },
+                            breakdown: [
+                                { type: "balance", value: clammPosition.userBalanceToken0 },
+                                { type: "liquidity", value: clammPosition.userInRangeLiquidity },
+                            ],
+                        },
+                        {
+                            token: {
+                                address: poolData.token1,
+                                decimals: poolData.decimalsToken1,
+                                symbol: poolData.symbolToken1,
+                            },
+                            breakdown: [
+                                { type: "balance", value: clammPosition.userBalanceToken1 },
+                                { type: "liquidity", value: clammPosition.userInRangeLiquidity },
+                            ],
+                        },
+                    ],
+                };
+                result.push(position);
+            }
+        }
+        return result;
+    };
+}

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

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

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

@@ -0,0 +1,45 @@
+import { Campaign } from "@sdk";
+import { utils } from "ethers";
+import { CampaignService } from "../../campaign";
+import { PositionRepository } from "../position.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 PositionRepository.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/position/implementations/ERC20PositionFetcher.d.ts

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

package/dist/src/modules/v4/position/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;
+    };
+}