@merkl/api 0.20.150 → 0.20.151

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

@@ -1,4 +1,3 @@
-import type { CacheKeys } from "@/cache/keys";
 import type { LightOpportunityFromDB, Opportunity } from "@/modules/v4/opportunity/opportunity.model";
 import type { Chain } from "@db/api";
 import { type CampaignDynamicData, Campaign as CampaignType, type ChainId, type MerklChainId } from "@sdk";
@@ -668,7 +667,7 @@ export declare abstract class RewardService {
         })[];
     })[];
     static findManyRootsOnChain(chainId: ChainId): Promise<string[]>;
-    static checkLastClaim(chainId: number, user: string, roots: CacheKeys["CurrentRoot"]["returns"], rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>): Promise<({
+    static checkLastClaim(chainId: number, user: string, rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>): Promise<({
         RewardToken: {
             symbol: string;
             id: string;

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

@@ -190,21 +190,22 @@ export class RewardService {
     static async findManyRootsOnChain(chainId) {
         return await CacheService.wrap(TTLPresets.MIN_10, RewardRepository.findManyRootsWithRewardOnChain, chainId);
     }
-    static async checkLastClaim(chainId, user, roots, rewards) {
+    static async checkLastClaim(chainId, user, rewards) {
+        // Fetch the root of the last claim for each reward token
         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 tokenId = TokenService.hashId(reward.RewardToken);
             const merklRootClaimedOn = claims[index].merkleRoot;
             // -> claim is on the current root (chainData.merklRoot) -> claimed === accumulated
-            if (merklRootClaimedOn === roots.live) {
+            if (merklRootClaimedOn === reward.root) {
                 reward.claimed = reward.amount;
                 await RewardRepository.updateRewardClaimed(user, tokenId, reward.amount);
                 for (const breakdown of reward.Breakdown) {
                     if (BigInt(breakdown.claimed) === BigInt(breakdown.amount))
                         continue;
                     breakdown.claimed = breakdown.amount; // Set unclaim to 0
-                    await RewardRepository.updateBreakdownClaimed(user, tokenId, reward.Breakdown[0].campaignId, reward.Breakdown[0].reason, reward.Breakdown[0].amount);
+                    await RewardRepository.updateBreakdownClaimed(user, tokenId, breakdown.campaignId, breakdown.reason, breakdown.amount);
                 }
             }
             // -> claim is on a tree we have in db -> claimed === accumulated of the rewards of lastTree
@@ -247,14 +248,14 @@ export class RewardService {
         const rewards = (await RewardService.getByRecipient(user, merkleRoots.map(({ live }) => live), withToken, withTestTokens)).filter(reward => chainIds.includes(reward.RewardToken.chainId) &&
             (claimableOnly ? BigInt(reward.amount) - BigInt(reward.claimed) > 0n : true));
         const promises = [];
-        for (const [index, chainId] of chainIds.entries()) {
+        for (const chainId of chainIds) {
             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 (chain.id === connectedChainId && chainRewards.length > 0) {
-                promises.push(RewardService.checkLastClaim(chainId, user, merkleRoots[index], chainRewards).then(r => {
+                promises.push(RewardService.checkLastClaim(chainId, user, chainRewards).then(r => {
                     return { chain, rewards: r };
                 }));
             }