@merkl/api 0.10.128 → 0.10.130

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

@@ -0,0 +1,237 @@
+import { apiDbClient } from "../../../utils/prisma";
+import { CampaignService } from "../campaign";
+import { TokenService } from "../token";
+import { UserService } from "../user";
+import { RewardService } from "./reward.service";
+export class RewardRepository {
+    static async createManyReward(rewards) {
+        const users = rewards.map(reward => {
+            return {
+                address: reward.recipient,
+                tags: [],
+            };
+        });
+        await UserService.createMany(users);
+        const rewardsToCreate = rewards.map(reward => {
+            const rewardTokenId = TokenService.hashId({ address: reward.rewardToken, chainId: reward.distributionChainId });
+            return {
+                id: RewardService.hashId(reward.root, reward.recipient, rewardTokenId),
+                root: reward.root,
+                recipient: reward.recipient,
+                rewardTokenId,
+                proofs: reward.proofs,
+            };
+        });
+        return await apiDbClient.reward.createMany({
+            data: rewardsToCreate,
+        });
+    }
+    static async createManyBreakdown(data) {
+        const breakdownsToCreate = [];
+        for (const dataPerCampaign of data) {
+            const campaignId = CampaignService.hashId({
+                distributionChain: dataPerCampaign.distributionChainId,
+                campaignId: dataPerCampaign.campaignId,
+            });
+            dataPerCampaign.breakdowns.map(breakdown => {
+                const rewardId = RewardService.hashId(dataPerCampaign.root, breakdown.recipient, TokenService.hashId({ address: dataPerCampaign.rewardToken, chainId: dataPerCampaign.distributionChainId }));
+                breakdownsToCreate.push({
+                    rewardId,
+                    protocolId: breakdown.protocolId ? breakdown.protocolId : undefined,
+                    campaignId,
+                    reason: breakdown.reason ? breakdown.reason : "",
+                    amount: breakdown.amount,
+                    claimed: breakdown.claimed,
+                    pending: breakdown.pending,
+                    auxiliaryData1: breakdown.auxiliaryData1 ?? "",
+                    auxiliaryData2: breakdown.auxiliaryData2 ?? "",
+                });
+            });
+        }
+        return await apiDbClient.rewardBreakdown.createMany({
+            data: breakdownsToCreate,
+        });
+    }
+    static async getByRecipient(recipient, roots, withToken) {
+        return await apiDbClient.reward.findMany({
+            where: {
+                root: {
+                    in: roots,
+                },
+                recipient,
+            },
+            include: {
+                Breakdown: {
+                    include: {
+                        Campaign: {
+                            select: {
+                                campaignId: true,
+                                Opportunity: {
+                                    include: {
+                                        MainProtocol: true,
+                                        Chain: true,
+                                        Protocols: true,
+                                        Tokens: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                RewardToken: withToken
+                    ? true
+                    : {
+                        select: { address: true, chainId: true, symbol: true, decimals: true },
+                    },
+            },
+        });
+    }
+    static async getByChainRecipientToken(recipient, root, tokenId) {
+        return await apiDbClient.reward.findUnique({
+            where: {
+                root_recipient_rewardTokenId: {
+                    root,
+                    recipient,
+                    rewardTokenId: tokenId,
+                },
+            },
+            include: {
+                Breakdown: {
+                    include: {
+                        Campaign: {
+                            select: { campaignId: true },
+                        },
+                    },
+                },
+            },
+        });
+    }
+    static async countRewardPerRewardTokenIdAndRoot() {
+        return await apiDbClient.reward.groupBy({
+            by: ["root", "rewardTokenId"],
+            _count: { _all: true },
+        });
+    }
+    static async countRewardBreakdownPerCampaignId() {
+        return await apiDbClient.rewardBreakdown.groupBy({
+            by: ["campaignId"],
+            _count: { _all: true },
+        });
+    }
+    static async updatePendings(rewardTokenId, root, campaignId, toUpdate) {
+        return await apiDbClient.$transaction(toUpdate.map(x => {
+            return apiDbClient.rewardBreakdown.update({
+                where: {
+                    rewardId_campaignId_reason: {
+                        rewardId: RewardService.hashId(root, x.recipient, rewardTokenId),
+                        campaignId: campaignId,
+                        reason: x.reason,
+                    },
+                },
+                data: {
+                    pending: x.pending,
+                    reason: x.reason,
+                    auxiliaryData1: x.auxiliaryData1,
+                    auxiliaryData2: x.auxiliaryData2,
+                },
+            });
+        }));
+    }
+    static async createPendings(rewardTokenId, root, campaignId, toCreate) {
+        const users = toCreate.map(x => x.recipient);
+        await UserService.createMany(users.map(x => ({ address: x, tags: [] })));
+        return await apiDbClient.$transaction(toCreate.map(x => {
+            const rewardId = RewardService.hashId(root, x.recipient, rewardTokenId);
+            return apiDbClient.rewardBreakdown.create({
+                data: {
+                    reason: x.reason,
+                    amount: "0",
+                    pending: x.pending,
+                    claimed: "0",
+                    Reward: {
+                        connectOrCreate: {
+                            where: { id: rewardId },
+                            create: {
+                                id: rewardId,
+                                MerklRoot: { connect: { root } },
+                                User: { connect: { address: x.recipient } },
+                                RewardToken: { connect: { id: rewardTokenId } },
+                                proofs: [],
+                            },
+                        },
+                    },
+                    Campaign: { connect: { id: campaignId } },
+                },
+            });
+        }));
+    }
+    static async findManyRootsWithRewardOnChain(chainId) {
+        return (await apiDbClient.merklRoot.findMany({
+            where: {
+                chainId: chainId,
+                Rewards: {
+                    some: {},
+                },
+            },
+            select: {
+                root: true,
+            },
+        })).map(x => x.root);
+    }
+    static async breakdownForCampaign(root, id, query) {
+        const { page: _page, items: _items } = query;
+        const page = _page || 0;
+        const items = _items || 50;
+        const result = await apiDbClient.$queryRawUnsafe(`
+      SELECT 
+        rb."amount",
+        rb."reason",
+        r."recipient"
+      FROM 
+        "RewardBreakdown" rb
+      INNER JOIN 
+        "Reward" r ON rb."rewardId" = r."id"
+      INNER JOIN 
+        "Campaign" c ON rb."campaignId" = c."id"
+      INNER JOIN 
+        "Token" t ON r."rewardTokenId" = t."id"
+      WHERE 
+        r."root" = $1 AND rb."campaignId" = $2
+      ORDER BY 
+        rb."amount"::numeric DESC
+      LIMIT $3
+      OFFSET $4
+    `, root, id, items, items * page);
+        return result;
+    }
+    static async total(campaignId, root) {
+        const totalAmount = await apiDbClient.rewardBreakdown.findMany({
+            where: {
+                campaignId,
+                Reward: {
+                    root,
+                },
+            },
+            select: {
+                amount: true,
+                campaignId: true,
+            },
+        });
+        const reducedData = totalAmount.reduce((acc, { amount }) => {
+            acc.amount += BigInt(amount);
+            return acc;
+        }, { campaignId, amount: 0n });
+        return reducedData;
+    }
+    static async count(campaignId, root) {
+        const count = await apiDbClient.rewardBreakdown.count({
+            where: {
+                campaignId,
+                Reward: {
+                    root,
+                },
+            },
+        });
+        return { count };
+    }
+}

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

@@ -0,0 +1,283 @@
+import { log } from "../../../utils/logger";
+import { Campaign, DistributorService, NETWORK_LABELS } from "@sdk";
+import moment from "moment";
+import { BlacklistService } from "../blacklist";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { CampaignService } from "../campaign";
+import { ChainService } from "../chain";
+import { MerklRootService } from "../merklRoot";
+import { OpportunityService } from "../opportunity";
+import { TokenService } from "../token";
+import { RewardRepository } from "./reward.repository";
+export class RewardService {
+    static hashId(root, recipient, rewardTokenId) {
+        return Bun.hash(`${root}${recipient}${rewardTokenId}`).toString();
+    }
+    static hashDailyRewardsRecordId(opportunityId, timestamp) {
+        return Bun.hash(`${opportunityId}${timestamp}`).toString();
+    }
+    static async createManyReward(rewards) {
+        return await RewardRepository.createManyReward(rewards);
+    }
+    /**
+     * Format the reward breakdown to conform to its resource model declaration
+     * @param breakdown straight from db
+     * @returns a RewardBreakdown model
+     */
+    static formatBreakdown(breakdown) {
+        const { Campaign, id, rewardId, protocolId, ...rest } = breakdown;
+        return {
+            ...rest,
+            campaignId: Campaign.campaignId,
+            opportunity: Campaign.Opportunity,
+        };
+    }
+    /**
+     * Format the reward to conform to its resource model declaration
+     * @param reward straight from db
+     * @returns a Reward model
+     */
+    static format(rewards) {
+        return rewards.map(reward => {
+            const { Breakdown, RewardToken, id, rewardTokenId, ...rest } = reward;
+            const claimed = Breakdown.reduce((sum, { claimed }) => sum + BigInt(claimed), 0n);
+            const amount = Breakdown.reduce((sum, { amount }) => sum + BigInt(amount), 0n);
+            const pending = Breakdown.reduce((sum, { pending }) => sum + BigInt(pending), 0n);
+            return {
+                ...rest,
+                token: RewardToken,
+                breakdowns: Breakdown.map(RewardService.formatBreakdown),
+                claimed,
+                amount,
+                pending,
+            };
+        });
+    }
+    static async createManyBreakdown(data) {
+        const missingCampaigns = [];
+        const foundCampaigns = [];
+        for (const dataPerCampaign of data) {
+            const campaignUnique = {
+                distributionChain: dataPerCampaign.distributionChainId,
+                campaignId: dataPerCampaign.campaignId,
+            };
+            const campaignExists = await CampaignService.checkIfExist(campaignUnique);
+            if (!campaignExists) {
+                const { success, fail } = await CampaignService.fill([campaignUnique]);
+                if (fail === 1 || success !== 1) {
+                    missingCampaigns.push(CampaignService.hashId(campaignUnique));
+                    log.warn(`createManyBreakdown - Missing campaign: ${campaignUnique.campaignId} on ${NETWORK_LABELS[campaignUnique.distributionChain]}`);
+                    continue;
+                }
+            }
+            foundCampaigns.push(CampaignService.hashId(campaignUnique));
+        }
+        try {
+            return await RewardRepository.createManyBreakdown(data.filter(dataPerCampaign => !missingCampaigns.includes(CampaignService.hashId({
+                distributionChain: dataPerCampaign.distributionChainId,
+                campaignId: dataPerCampaign.campaignId,
+            }))));
+        }
+        catch (e) {
+            log.error(`createManyBreakdown - error creating many breakdowns for campaigns ${foundCampaigns.join(", ")}`, e);
+        }
+    }
+    static async getByRecipient(recipient, roots, withToken = false) {
+        return await RewardRepository.getByRecipient(recipient, roots, withToken);
+    }
+    /**
+     * Groups a breakdown array by their corresponding opportunities
+     * @param breakdowns with campaignIds
+     * @returns array of breakdown group, including the opportunity they belong to
+     */
+    static splitBreakdownByOpportunity(breakdowns) {
+        const opportunities = breakdowns.reduce((aux, { opportunity }) => {
+            if (!aux.some(o => o.id === opportunity.id))
+                aux.push(opportunity);
+            return aux;
+        }, []);
+        if (!opportunities)
+            return [];
+        return opportunities.map(opportunity => {
+            const relatedBreakdowns = breakdowns.filter(b => opportunity.id.includes(b.opportunity.id));
+            const formattedOpportunity = OpportunityService.formatResponseBase(opportunity);
+            return {
+                opportunity: formattedOpportunity,
+                claimed: relatedBreakdowns.reduce((total, { claimed }) => total + BigInt(claimed), 0n),
+                amount: relatedBreakdowns.reduce((total, { amount }) => total + BigInt(amount), 0n),
+                pending: relatedBreakdowns.reduce((total, { pending }) => total + BigInt(pending), 0n),
+                auxiliaryData1: relatedBreakdowns[0]?.auxiliaryData1,
+                auxiliaryData2: relatedBreakdowns[0]?.auxiliaryData2,
+            };
+        });
+    }
+    /**
+     * Applies the splitBreakdownByOpportunity function to each rewards in the array
+     * @param rewards return type for most of the rewards functions
+     * @returns rewards with updated breakdowns, including the opportunity they belong to
+     */
+    static splitRewardsBreakdownByOpportunity(rewards) {
+        return rewards.map(rewardByChain => {
+            const rewards = rewardByChain.rewards.map(reward => {
+                const breakdowns = RewardService.splitBreakdownByOpportunity(reward.breakdowns);
+                return Object.assign(reward, { breakdowns });
+            });
+            const distributor = DistributorService(rewardByChain.chain.id).address;
+            return Object.assign(rewardByChain, { rewards }, { distributor });
+        });
+    }
+    static removeOpportunityFromRewardBreakdown(rewards) {
+        return rewards.map(rewardByChain => {
+            const rewards = rewardByChain.rewards.map(reward => {
+                const breakdowns = reward.breakdowns.map(breakdown => {
+                    const { opportunity, ...rest } = breakdown;
+                    return rest;
+                });
+                return Object.assign(reward, { breakdowns });
+            });
+            return Object.assign(rewardByChain, { rewards });
+        });
+    }
+    static async findManyRootsOnChain(chainId) {
+        return await CacheService.wrap(TTLPresets.MIN_10, RewardRepository.findManyRootsWithRewardOnChain, chainId);
+    }
+    static async checkLastClaim(chainId, user, roots, rewards) {
+        const claims = await DistributorService(chainId).claimedMultiple(user, rewards.map(reward => reward.RewardToken.address));
+        const rootsWithRewardOnChain = await RewardService.findManyRootsOnChain(chainId);
+        for (const [index, reward] of rewards.entries()) {
+            const merklRootClaimedOn = claims[index].merkleRoot;
+            // -> claim is on the current root (chainData.merklRoot) -> claimed === accumulated
+            if (merklRootClaimedOn === roots.live) {
+                for (const breakdown of reward.Breakdown) {
+                    breakdown.claimed = breakdown.amount; // Set unclaim to 0
+                }
+            }
+            // -> claim is on a tree we have in db -> claimed === accumulated of the rewards of lastTree
+            else if (rootsWithRewardOnChain.includes(merklRootClaimedOn)) {
+                const lastTreeRewards = await RewardRepository.getByChainRecipientToken(user, merklRootClaimedOn, TokenService.hashId(reward.RewardToken));
+                if (!lastTreeRewards)
+                    continue;
+                for (const breakdown of reward.Breakdown) {
+                    const lastTreeRewardsBreakdown = lastTreeRewards.Breakdown.find(lastTreeBreakdown => lastTreeBreakdown.reason === breakdown.reason &&
+                        lastTreeBreakdown.Campaign.campaignId === breakdown.Campaign.campaignId);
+                    if (!lastTreeRewardsBreakdown)
+                        continue;
+                    breakdown.claimed = lastTreeRewardsBreakdown.amount;
+                }
+            }
+        }
+        return rewards;
+    }
+    static async getUserRewardsByChain(user, withToken, chainFilter = []) {
+        const chains = await ChainService.findMany();
+        let chainIds = chains.map(({ id }) => id).filter(id => !chainFilter.length || chainFilter.includes(id));
+        /** Check if the user is blacklisted */
+        const isBlacklisted = !!(await BlacklistService.isBlacklisted(user));
+        const res = [];
+        if (isBlacklisted)
+            return res;
+        /** Fetch current Merkle Roots */
+        const merkleRootsPromises = await Promise.allSettled(chainIds.map(chainId => MerklRootService.fetch(chainId)));
+        /** Filter out unsuccessful chainIds */
+        chainIds = chainIds.filter((_, index) => merkleRootsPromises[index].status === "fulfilled");
+        const merkleRoots = merkleRootsPromises
+            .filter(({ status }) => status === "fulfilled")
+            .map(x => x.value);
+        /** Load rewards from api DB */
+        const rewards = (await RewardService.getByRecipient(user, merkleRoots.map(({ live }) => live), withToken)).filter(reward => chainIds.includes(reward.RewardToken.chainId));
+        const promises = [];
+        for (const [index, chainId] of chainIds.entries()) {
+            const chain = chains.find(chain => chain.id === chainId);
+            if (!chain)
+                throw new Error(`Chain ${chainId} not found`);
+            const chainRewards = rewards.filter(reward => reward.RewardToken.chainId === chainId);
+            /** Check when the last claim happened */
+            if (chainRewards.length > 0) {
+                promises.push(RewardService.checkLastClaim(chainId, user, merkleRoots[index], chainRewards).then(r => res.push({ chain, rewards: RewardService.format(r) })));
+            }
+        }
+        const settledPromises = await Promise.allSettled(promises);
+        for (const promise of settledPromises) {
+            if (promise.status === "rejected") {
+                log.error("checkLastClaim failed", promise.reason);
+            }
+        }
+        return res;
+    }
+    static async updatePendings(data) {
+        const rewardTokenId = await TokenService.hashId({ address: data.rewardToken, chainId: data.distributionChainId });
+        const campaignId = await CampaignService.hashId({
+            distributionChain: data.distributionChainId,
+            campaignId: data.campaignId,
+        });
+        try {
+            await RewardRepository.updatePendings(rewardTokenId, data.root, campaignId, data.toUpdate);
+        }
+        catch (e) {
+            log.error("Error updating pendings", `rewardTokenId: ${rewardTokenId}, campaignId: ${campaignId}, root: ${data.root}`);
+            console.error(e);
+        }
+        await RewardRepository.createPendings(rewardTokenId, data.root, campaignId, data.toCreate);
+        return true;
+    }
+    static async countAllchains() {
+        const rewardPerRewardTokenId = await RewardRepository.countRewardPerRewardTokenIdAndRoot();
+        const rewardBreakdownPerCampaignId = await RewardRepository.countRewardBreakdownPerCampaignId();
+        const tokenIdToChain = await TokenService.findChains();
+        const campaignIdToChain = await CampaignService.findChains();
+        const res = {};
+        for (const { _count, rewardTokenId, root } of rewardPerRewardTokenId) {
+            const chainId = tokenIdToChain[rewardTokenId];
+            if (!chainId)
+                continue;
+            if (!res[NETWORK_LABELS[chainId]])
+                res[NETWORK_LABELS[chainId]] = { rewards: {}, breakdown: 0 };
+            if (!res[NETWORK_LABELS[chainId]].rewards[root])
+                res[NETWORK_LABELS[chainId]].rewards[root] = 0;
+            res[NETWORK_LABELS[chainId]].rewards[root] += _count._all;
+        }
+        for (const { _count, campaignId } of rewardBreakdownPerCampaignId) {
+            const chainId = campaignIdToChain[campaignId];
+            if (!chainId)
+                continue;
+            res[NETWORK_LABELS[chainId]].breakdown += _count._all;
+        }
+        return res;
+    }
+    static async breakdownForCampaign(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
+        return RewardRepository.breakdownForCampaign(root.live, id, query);
+    }
+    static async count(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
+        return RewardRepository.count(id, root.live);
+    }
+    static async total(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        return RewardRepository.total(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
+    }
+    static async extractDailyRewardsRecordFromDynamicData(type, dynamicData, timestamp = BigInt(moment().unix())) {
+        const typesWithoutApr = [Campaign.INVALID];
+        if (typesWithoutApr.includes(type))
+            return { timestamp, total: 0, breakdowns: [] };
+        const breakdowns = [];
+        for (const { amount, rewardToken: address, chainId, startTimestamp: start, endTimestamp: end, campaignId, } of dynamicData) {
+            const timespan = Math.abs(end - start);
+            const dayspan = Math.max(1, Math.floor(timespan / (60 * 60 * 24)));
+            const dailyAmount = BigInt(amount) / BigInt(dayspan);
+            const campaignDailyValue = await TokenService.getValue([{ amount: dailyAmount, address, chainId }]);
+            breakdowns.push({
+                campaignId: CampaignService.hashId({ campaignId, distributionChain: chainId }),
+                value: campaignDailyValue,
+            });
+        }
+        return {
+            timestamp,
+            total: breakdowns.reduce((sum, { value }) => sum + value, 0),
+            breakdowns,
+        };
+    }
+}

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

@@ -0,0 +1,136 @@
+import { RewardService } from "./reward.service";
+export class RewardConvertorService {
+    /**
+     * Convert the v4 reward data to the v3 model used in the v3/userRewards route
+     */
+    static convertV4toUserRewardV3(data, includeProofs = false) {
+        const res = {};
+        for (const { chain: _chain, rewards } of data) {
+            for (const reward of rewards) {
+                const { token, breakdowns, proofs } = reward;
+                const rewardToken = token.address;
+                res[rewardToken] = {
+                    accumulated: "0",
+                    decimals: token.decimals,
+                    symbol: token.symbol,
+                    unclaimed: "0",
+                    pending: "0",
+                    proof: includeProofs ? proofs : undefined,
+                    reasons: {},
+                };
+                for (const breakdown of breakdowns) {
+                    const { amount, claimed, pending, reason } = breakdown;
+                    if (!res[rewardToken].reasons[reason]) {
+                        res[rewardToken].reasons[reason] = {
+                            accumulated: amount,
+                            unclaimed: (BigInt(amount) - BigInt(claimed)).toString(),
+                            pending,
+                        };
+                    }
+                    else {
+                        res[rewardToken].reasons[reason].accumulated = (BigInt(res[rewardToken].reasons[reason].accumulated) + BigInt(amount)).toString();
+                        res[rewardToken].reasons[reason].unclaimed = (BigInt(res[rewardToken].reasons[reason].unclaimed) +
+                            BigInt(amount) -
+                            BigInt(claimed)).toString();
+                        res[rewardToken].reasons[reason].pending = (BigInt(res[rewardToken].reasons[reason].pending ?? "0") + BigInt(pending)).toString();
+                    }
+                    res[rewardToken].accumulated = (BigInt(res[rewardToken].accumulated) + BigInt(amount)).toString();
+                    res[rewardToken].unclaimed = (BigInt(res[rewardToken].unclaimed) +
+                        BigInt(amount) -
+                        BigInt(claimed)).toString();
+                    res[rewardToken].pending = (BigInt(res[rewardToken].pending ?? "0") + BigInt(pending)).toString();
+                }
+            }
+        }
+        return res;
+    }
+    /**
+     * Convert the v4 reward data to the v3 model used in the v3/rewards route
+     */
+    static convertV4toRewardV3(data) {
+        const res = {};
+        for (const { chain, rewards } of data) {
+            res[chain.id] = {
+                campaignData: {},
+                tokenData: {},
+            };
+            for (const reward of rewards) {
+                const { token, breakdowns, proofs } = reward;
+                const rewardToken = token.address;
+                if (!res[chain.id].tokenData[rewardToken]) {
+                    res[chain.id].tokenData[rewardToken] = {
+                        accumulated: "0",
+                        unclaimed: "0",
+                        pending: "0",
+                        decimals: token.decimals,
+                        symbol: token.symbol,
+                        proof: proofs,
+                    };
+                }
+                for (const breakdown of breakdowns) {
+                    const { amount, claimed, pending, reason, campaignId } = breakdown;
+                    if (!res[chain.id].campaignData[campaignId]) {
+                        res[chain.id].campaignData[campaignId] = {};
+                    }
+                    if (!res[chain.id].campaignData[campaignId][reason]) {
+                        res[chain.id].campaignData[campaignId][reason] = {
+                            accumulated: "0",
+                            unclaimed: "0",
+                            pending: "0",
+                            auxiliaryData1: breakdown.auxiliaryData1 === "" ? "0" : breakdown.auxiliaryData1 ?? "0",
+                            auxiliaryData2: breakdown.auxiliaryData2 === "" ? "0" : breakdown.auxiliaryData2 ?? "0",
+                            decimals: token.decimals,
+                            mainParameter: breakdown.opportunity.identifier,
+                            symbol: token.symbol,
+                            token: rewardToken,
+                        };
+                    }
+                    res[chain.id].tokenData[rewardToken].accumulated = (BigInt(res[chain.id].tokenData[rewardToken].accumulated) + BigInt(amount)).toString();
+                    res[chain.id].tokenData[rewardToken].unclaimed = (BigInt(res[chain.id].tokenData[rewardToken].unclaimed) +
+                        BigInt(amount) -
+                        BigInt(claimed)).toString();
+                    res[chain.id].tokenData[rewardToken].pending = (BigInt(pending ?? "0") + BigInt(pending)).toString();
+                    res[chain.id].campaignData[campaignId][reason].accumulated = (BigInt(res[chain.id].campaignData[campaignId][reason].accumulated) + BigInt(amount)).toString();
+                    res[chain.id].campaignData[campaignId][reason].unclaimed = (BigInt(res[chain.id].campaignData[campaignId][reason].unclaimed) +
+                        BigInt(amount) -
+                        BigInt(claimed)).toString();
+                    res[chain.id].campaignData[campaignId][reason].pending = (BigInt(res[chain.id].campaignData[campaignId][reason].pending ?? "0") + BigInt(pending)).toString();
+                }
+            }
+        }
+        return res;
+    }
+    static async convertV4toMerklV2(user, chainId, data) {
+        const rewardsV4 = await RewardService.getUserRewardsByChain(user, false, [chainId]);
+        if (!!rewardsV4?.[0]?.rewards) {
+            const userType = {
+                transactionData: rewardsV4[0].rewards.reduce((acc, reward) => {
+                    acc[reward.token.address] = {
+                        claim: (BigInt(reward.amount) - BigInt(reward.claimed)).toString(),
+                        leaf: reward.proofs?.[0],
+                        proof: reward.proofs,
+                        token: reward.token.address,
+                    };
+                    return acc;
+                }, {}),
+            };
+            data = { ...data, ...userType };
+        }
+        for (const rewardsPerChain of rewardsV4) {
+            for (const reward of rewardsPerChain.rewards) {
+                for (const breakdown of reward.breakdowns) {
+                    const mainParameter = breakdown?.opportunity?.identifier;
+                    if (!!mainParameter) {
+                        const campaignIndex = data?.pools?.[mainParameter]?.distributionData?.findIndex(d => d.id === breakdown.campaignId);
+                        if (campaignIndex >= 0) {
+                            data.pools[mainParameter].distributionData[campaignIndex].unclaimed =
+                                (data.pools[mainParameter].distributionData[campaignIndex].unclaimed ?? 0) +
+                                    Number.parseInt((BigInt(reward.amount) - BigInt(reward.claimed)).toString());
+                        }
+                    }
+                }
+            }
+        }
+        return data;
+    }
+}