@merkl/api 0.10.168 → 0.10.169

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;
+    };
+}

package/dist/src/modules/v4/position/implementations/EulerPositionFetcher.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 EulerPositionFetcher implements PositionFetcher {
+    fetchPositions: (chainId: MerklChainId, user: string, opportunities: Opportunity["model"][]) => Promise<PositionT[]>;
+}

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

@@ -0,0 +1,40 @@
+import { BN2Number, Campaign, ChainInteractionService, ERC20Interface } from "@sdk";
+const campaignType = Campaign.EULER;
+export class EulerPositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
+        const calls = [];
+        for (const opportunity of opportunities) {
+            // Call per opportunity
+            for (const token of opportunity.tokens) {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
+                    target: token.address,
+                });
+            }
+        }
+        const res = await ChainInteractionService(chainId).fetchState(calls);
+        const result = [];
+        for (const [index, opportunity] of opportunities.entries()) {
+            // Decoding calls per opportunity
+            for (const [subIndex, token] of opportunity.tokens.entries()) {
+                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/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./position.model";
+export * from "./position.service";

package/dist/src/modules/v4/position/index.js

@@ -0,0 +1,2 @@
+export * from "./position.model";
+export * from "./position.service";

package/dist/src/modules/v4/position/position.controller.d.ts

@@ -0,0 +1,39 @@
+import { Elysia } from "elysia";
+export declare const PositionController: Elysia<"/positions", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    positions: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    chainId: number;
+                    address: string;
+                };
+                headers: unknown;
+                response: {
+                    200: any[];
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,16 @@
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
+import { Elysia } from "elysia";
+import { PositionsInputDto } from "./position.model";
+import { PositionService } from "./position.service";
+// ─── Positions Controller ──────────────────────────────────────────────
+export const PositionController = new Elysia({ prefix: "/positions", detail: { tags: ["Positions"] } })
+    // ─── Get User Positions on a Chain ───────────────────────────────────
+    .get("/", async ({ query }) => {
+    return await PositionService.fetchPositions(query);
+}, {
+    query: PositionsInputDto,
+    beforeHandle: ({ query }) => {
+        throwOnUnsupportedChainId(query.chainId);
+        query.address = throwOnInvalidRequiredAddress(query.address);
+    },
+});

package/dist/src/modules/v4/position/position.model.d.ts

@@ -0,0 +1,25 @@
+import type { MerklChainId } from "@sdk";
+import type { Opportunity } from "../opportunity";
+export type PositionT = {
+    flags: {
+        range?: string;
+        id?: string;
+        link?: string;
+    };
+    opportunity: Opportunity["model"];
+    tokens: {
+        token: Opportunity["model"]["tokens"][0];
+        breakdown: {
+            type: string;
+            value: number;
+        }[];
+    }[];
+};
+export interface PositionFetcher {
+    fetchPositions(chainId: MerklChainId, user: string, opportunity: Opportunity["model"][]): Promise<PositionT[]>;
+}
+export declare const PositionsInputDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    address: import("@sinclair/typebox").TString;
+}>;
+export type PositionsInputModel = typeof PositionsInputDto.static;

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

@@ -0,0 +1,5 @@
+import { t } from "elysia";
+export const PositionsInputDto = t.Object({
+    chainId: t.Numeric(),
+    address: t.String(),
+});

package/dist/src/modules/v4/position/position.repository.d.ts

@@ -0,0 +1,14 @@
+import type { MerklChainId } from "@sdk";
+export declare class PositionRepository {
+    static findManyDolomitePositions(chainId: MerklChainId, user: string): Promise<{
+        balance: string;
+        token: {
+            id: string;
+            marketId: string;
+            symbol: string;
+            decimals: string;
+            borrowLiquidity: string;
+            supplyLiquidity: string;
+        };
+    }[]>;
+}

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

@@ -0,0 +1,6 @@
+import axios from "axios";
+export class PositionRepository {
+    static async findManyDolomitePositions(chainId, user) {
+        return (await axios.get(`https://api.dolomite.io/balances/${chainId}/users/${user}`)).data.Result;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PositionsInputModel } from "./position.model";
+export declare class PositionService {
+    #private;
+    static fetchPositions(query: PositionsInputModel): Promise<any[]>;
+}

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

@@ -0,0 +1,34 @@
+import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "../../../constants";
+import { Campaign, withTimeout } from "@sdk";
+import { OpportunityService } from "../opportunity";
+import { AjnaPositionFetcher } from "./implementations/AjnaPositionFetcher";
+import { BadgerPositionFetcher } from "./implementations/BadgerPositionFetcher";
+import { ClammPositionFetcher } from "./implementations/ClammPositionFetcher";
+import { DolomitePositionFetcher } from "./implementations/DolomitePositionFetcher";
+import { ERC20PositionFetcher } from "./implementations/ERC20PositionFetcher";
+import { EulerPositionFetcher } from "./implementations/EulerPositionFetcher";
+export class PositionService {
+    static #fetchers = {
+        [Campaign.ERC20]: new ERC20PositionFetcher(),
+        [Campaign.EULER]: new EulerPositionFetcher(),
+        [Campaign.AJNA]: new AjnaPositionFetcher(),
+        [Campaign.BADGER]: new BadgerPositionFetcher(),
+        [Campaign.CLAMM]: new ClammPositionFetcher(),
+        [Campaign.DOLOMITE]: new DolomitePositionFetcher(),
+    };
+    static async fetchPositions(query) {
+        const opportunities = await OpportunityService.findLiveWithFirstCampaign(query.chainId);
+        const promises = [];
+        for (const campaignType of Object.keys(Campaign)) {
+            const fetcher = PositionService.#fetchers[Number.parseInt(campaignType)];
+            if (fetcher) {
+                promises.push(withTimeout(fetcher.fetchPositions(query.chainId, query.address, opportunities.filter(o => !!o)), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
+            }
+        }
+        const settledPromises = await Promise.allSettled(promises);
+        for (const errors of settledPromises.filter(p => p.status === "rejected")) {
+            console.error(errors.reason);
+        }
+        return settledPromises.filter(p => p.status === "fulfilled").flatMap(p => p.value);
+    }
+}

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

@@ -532,6 +532,11 @@ export declare abstract class RewardService {
         campaignId: string;
         amount: bigint;
     }>;
+    static getAmountAndClaimedForCampaigns(x: CampaignIdWithoutPageModel): Promise<{
+        campaignId: string;
+        amount: string;
+        claimed: string;
+    }[]>;
     static getUnclaimed(x: CampaignIdWithoutPageModel): Promise<Record<string, string>>;
     static extractDailyRewardsRecordFromDynamicData<C extends Campaign>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): Promise<DailyRewardsRecord["model"]>;
 }

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

@@ -259,13 +259,16 @@ export class RewardService {
         const root = await MerklRootService.fetch(query.chainId);
         return RewardRepository.total(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
     }
+    static async getAmountAndClaimedForCampaigns(x) {
+        const currentRoot = await MerklRootService.fetch(x.chainId);
+        return await RewardRepository.getAmountAndClaimedForCampaigns(currentRoot.live, x);
+    }
     static async getUnclaimed(x) {
         const campaignToCampaignIds = x.campaignIds.reduce((acc, campaignId) => {
             acc[CampaignService.hashId({ distributionChain: x.chainId, campaignId })] = campaignId;
             return acc;
         }, {});
-        const currentRoot = await MerklRootService.fetch(x.chainId);
-        const data = await RewardRepository.getAmountAndClaimedForCampaigns(currentRoot.live, x);
+        const data = await RewardService.getAmountAndClaimedForCampaigns(x);
         return data.reduce((acc, { amount, campaignId, claimed }) => {
             if (!acc[campaignToCampaignIds[campaignId]])
                 acc[campaignToCampaignIds[campaignId]] = "0";