@merkl/api 0.20.87 → 0.20.89

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

@@ -1,15 +1,191 @@
+import { campaignDynamicDataBuilderFactory } from "@/engine/campaignTVL/factory";
 import { dynamicDataBuilderFactory } from "@/engine/dynamicData/factory";
 import { HttpError } from "@/errors";
+import { InvalidParameter } from "@/errors/InvalidParameter.error";
 import { OpportunityRepository } from "@/modules/v4/opportunity/opportunity.repository";
 import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
 import { RewardService } from "@/modules/v4/reward/reward.service";
 import { TvlService } from "@/modules/v4/tvl/tvl.service";
 import bigintToString from "@/utils/bigintToString";
 import { log } from "@/utils/logger";
-import { Campaign, NETWORK_LABELS } from "@sdk";
-import { Campaign as CampaignEnum } from "@sdk";
+import { AprType } from "@db/api";
+import { Campaign as CampaignEnum, DAY, NETWORK_LABELS, } from "@sdk";
+import moment from "moment";
 import { AprService } from "../apr";
+import { CampaignService } from "../campaign";
+import { TokenService } from "../token/token.service";
 export class DynamicDataService {
+    /**
+     * @notice Updates all records for opportunities associated to the given campaigns
+     *
+     * @dev The list must ONLY contain campaigns of the same type and the same computeChainId
+     */
+    static async update(chainId, type, campaigns, dryRun = false) {
+        // 1 - Safety check
+        for (const campaign of campaigns) {
+            if (campaign.computeChainId !== chainId || campaign.campaignType !== type) {
+                throw new InvalidParameter(`Campaign ${campaign.campaignId} is not of type ${type} on chain ${chainId}`);
+            }
+        }
+        // 2 - If the new dynamic data builder is available, use it
+        const builder = campaignDynamicDataBuilderFactory(type);
+        if (!!builder) {
+            // 2.a - Call the builder
+            const records = await DynamicDataService.fetchWithRecursiveErrorHandling(builder.build, campaigns, chainId);
+            // 2.b - Regroup by opportunity and build records
+            const opportunityIds = new Set(records.map(r => OpportunityService.hashId({
+                chainId,
+                identifier: r.campaign.mainParameter,
+                type: CampaignEnum[+type],
+            })));
+            const now = moment().unix();
+            const updates = [];
+            for (const opportunityId of opportunityIds) {
+                const recordsForOpportunity = records.filter(r => OpportunityService.hashId({
+                    chainId,
+                    identifier: r.campaign.mainParameter,
+                    type: CampaignEnum[+type],
+                }) === opportunityId);
+                const tvl = {
+                    timestamp: BigInt(now),
+                    total: 0,
+                    breakdowns: [],
+                };
+                const dailyRewards = {
+                    timestamp: BigInt(now),
+                    total: 0,
+                    breakdowns: [],
+                };
+                const apr = {
+                    timestamp: BigInt(now),
+                    cumulated: 0,
+                    breakdowns: [],
+                };
+                for (const record of recordsForOpportunity) {
+                    // 2.b.1 TVL of the opportunity is the max of all TVLs of the campaigns
+                    if (record.tvl > tvl.total) {
+                        tvl.total = record.tvl;
+                        tvl.breakdowns = record.tvlBreakdown;
+                    }
+                    const startTimestamp = record.campaign.startTimestamp;
+                    const endTimestamp = record.campaign.endTimestamp;
+                    const rewardToken = record.campaign.rewardToken;
+                    try {
+                        // 2.b.2 Daily rewards is the sum of all daily rewards of the campaigns
+                        const timespan = endTimestamp - startTimestamp;
+                        const isWithinTimespan = moment().unix() > startTimestamp && moment().unix() < endTimestamp;
+                        const dayspan = Math.max(1, Math.floor(timespan / DAY));
+                        const dailyAmount = isWithinTimespan ? BigInt(record.campaign.amount) / BigInt(dayspan) : BigInt(0);
+                        let token;
+                        try {
+                            token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
+                        }
+                        catch {
+                            await TokenService.findManyOrCreate([{ address: rewardToken, chainId }]);
+                            token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
+                        }
+                        const campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardToken, chainId }), dailyAmount);
+                        dailyRewards.total += campaignDailyValue;
+                        dailyRewards.breakdowns.push({
+                            campaignId: CampaignService.hashId({
+                                campaignId: record.campaign.campaignId,
+                                distributionChain: record.campaign.chainId,
+                            }),
+                            value: campaignDailyValue,
+                            amount: dailyAmount,
+                            token,
+                        });
+                        // 2.b.3 APR is obtained from daily rewards and tvl following the distribution type
+                        // TODO: switch on distribution type - dailyRewards can be in token amount
+                        apr.cumulated += campaignDailyValue / record.tvl;
+                        apr.breakdowns.push({
+                            identifier: record.campaign.campaignId,
+                            type: AprType.CAMPAIGN,
+                            value: campaignDailyValue / record.tvl,
+                        });
+                    }
+                    catch (_err) {
+                        log.warn(`token ${rewardToken} not found`);
+                    }
+                    updates.push({
+                        opportunityId,
+                        tvl,
+                        apr,
+                        dailyRewards,
+                    });
+                }
+                updates.push({
+                    opportunityId,
+                    tvl,
+                    apr,
+                    dailyRewards,
+                });
+            }
+            // 2.c - Update the records
+            for (const update of updates) {
+                try {
+                    if (!dryRun)
+                        await OpportunityRepository.updateDynamicData(update.opportunityId, update.apr, update.tvl, update.dailyRewards);
+                }
+                catch (err) {
+                    throw new HttpError("Failed to update dynamic data", 500, {
+                        err,
+                        chainId,
+                        type,
+                    });
+                }
+            }
+        }
+        else {
+            const dynamicDataArray = [];
+            const dynamicData = await DynamicDataService.fetchWithRecursiveErrorHandling(dynamicDataBuilderFactory(type).build, campaigns, chainId);
+            const oppMap = {};
+            for (const data of dynamicData) {
+                if (!!data) {
+                    // Main Parameter OVERRIDING
+                    if (data.campaignType === CampaignEnum.SILO && data.campaignParameters.whitelist?.length === 1)
+                        data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
+                    if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
+                        oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
+                    oppMap[`${data.campaignType}_${data.mainParameter}`][data.campaignId] = data;
+                }
+            }
+            for (const entry of Object.entries(oppMap)) {
+                const [type, mainParameter] = entry[0].split("_");
+                const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
+                const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
+                const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
+                const opportunityId = OpportunityService.hashId({
+                    chainId,
+                    identifier: mainParameter,
+                    type: CampaignEnum[+type],
+                });
+                try {
+                    if (!dryRun)
+                        await OpportunityRepository.updateDynamicData(opportunityId, apr, tvl, dailyRewards);
+                }
+                catch (err) {
+                    throw new HttpError("Failed to update dynamic data", 500, {
+                        err,
+                        opportunityId,
+                        campaigns: Object.values(entry[1]),
+                        dynamicData: bigintToString({
+                            campaignId: Object.values(entry[1])[0].campaignId,
+                            apr,
+                            tvl,
+                            dailyRewards,
+                        }),
+                    });
+                }
+                dynamicDataArray.push(bigintToString({ campaignId: Object.values(entry[1])[0].campaignId, apr, tvl, dailyRewards }));
+            }
+            log.info(`[${NETWORK_LABELS[chainId]}][${CampaignEnum[type]}] updated ${dynamicData.length}/${campaigns.length} campaigns`);
+            return dynamicDataArray;
+        }
+    }
+    /**
+     * @dev Test function used to create mock ERC20 static campaigns and check tvl and metadata
+     */
     static async queryERC20DynamicData(chainId, tokenAddress, rewardTokenAddress, symbolRewardToken, decimals = 18) {
         const campaigns = [
             {
@@ -38,11 +214,11 @@ export class DynamicDataService {
                     symbolTargetToken: "EXT",
                     targetToken: tokenAddress,
                 },
-                campaignType: Campaign.ERC20,
+                campaignType: CampaignEnum.ERC20,
             },
         ];
         log.info(`querying mock campaign on chain: ${NETWORK_LABELS[chainId]}`);
-        const result = await dynamicDataBuilderFactory(Campaign.ERC20).build(Number(chainId), campaigns);
+        const result = await dynamicDataBuilderFactory(CampaignEnum.ERC20).build(Number(chainId), campaigns);
         return {
             priceTargetToken: result[0]?.typeInfo.priceTargetToken,
             totalSupply: result[0]?.typeInfo.totalSupply,
@@ -52,13 +228,15 @@ export class DynamicDataService {
             type: result[0]?.type ?? "defaultType",
         };
     }
-    static async getDynamicData(campaigns, type, chainId) {
+    /**
+     * @dev Recursive function to handle errors in fetching dynamic data
+     */
+    static async fetchWithRecursiveErrorHandling(fn, campaigns, chainId) {
         // Base case: empty input
         if (campaigns.length === 0)
             return [];
         try {
-            const campaignType = typeof type === "number" ? type : Campaign[type];
-            return await dynamicDataBuilderFactory(campaignType).build(chainId, campaigns);
+            return await fn(chainId, campaigns);
         }
         catch (error) {
             // Base case: single failing campaign
@@ -70,85 +248,11 @@ export class DynamicDataService {
             const mid = Math.ceil(campaigns.length / 2);
             const [firstResults, secondResults] = await Promise.all([
                 // Process first half with error propagation
-                DynamicDataService.getDynamicData(campaigns.slice(0, mid), type, chainId),
+                DynamicDataService.fetchWithRecursiveErrorHandling(fn, campaigns.slice(0, mid), chainId),
                 // Process second half with error propagation
-                DynamicDataService.getDynamicData(campaigns.slice(mid), type, chainId),
+                DynamicDataService.fetchWithRecursiveErrorHandling(fn, campaigns.slice(mid), chainId),
             ]);
             return [...firstResults, ...secondResults];
         }
     }
-    static async updateForCampaignType(campaigns, type, dryRun = false) {
-        const chainId = campaigns[0].computeChainId;
-        const dynamicDataArray = [];
-        const dynamicData = await DynamicDataService.getDynamicData(campaigns, typeof type === "number" ? type : Campaign[type], chainId);
-        const oppMap = {};
-        for (const data of dynamicData) {
-            if (!!data) {
-                // Main Parameter OVERRIDING
-                if (data.campaignType === CampaignEnum.SILO && data.campaignParameters.whitelist?.length === 1)
-                    data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
-                if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
-                    oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
-                oppMap[`${data.campaignType}_${data.mainParameter}`][data.campaignId] = data;
-            }
-        }
-        for (const entry of Object.entries(oppMap)) {
-            const [type, mainParameter] = entry[0].split("_");
-            const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
-            const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
-            const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
-            const opportunityId = OpportunityService.hashId({
-                chainId,
-                identifier: mainParameter,
-                type: Campaign[+type],
-            });
-            try {
-                if (!dryRun)
-                    await OpportunityRepository.updateDynamicData(opportunityId, apr, tvl, dailyRewards);
-            }
-            catch (err) {
-                throw new HttpError("Failed to update dynamic data", 500, {
-                    err,
-                    opportunityId,
-                    campaigns: Object.values(entry[1]),
-                    dynamicData: bigintToString({
-                        campaignId: Object.values(entry[1])[0].campaignId,
-                        apr,
-                        tvl,
-                        dailyRewards,
-                    }),
-                });
-            }
-            dynamicDataArray.push(bigintToString({ campaignId: Object.values(entry[1])[0].campaignId, apr, tvl, dailyRewards }));
-        }
-        log.info(`[${NETWORK_LABELS[chainId]}][${CampaignEnum[type]}] Updated ${dynamicData.length}/${campaigns.length} campaigns`);
-        return dynamicDataArray;
-    }
-    static async updateForCampaigns(campaigns, dryRun = false) {
-        const campaignTypeToCampaigns = new Map();
-        for (const campaign of campaigns) {
-            const type = campaign.campaignType;
-            const campaigns = campaignTypeToCampaigns.get(campaign.campaignType) ?? [];
-            campaigns.push(campaign);
-            campaignTypeToCampaigns.set(type, campaigns);
-        }
-        const dynamicDataArray = [];
-        for (const [campaignType, campaigns] of campaignTypeToCampaigns.entries()) {
-            try {
-                try {
-                    dynamicDataArray.push(await DynamicDataService.updateForCampaignType(campaigns, campaignType, dryRun));
-                }
-                catch (err) {
-                    console.error(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, err);
-                }
-            }
-            catch (err) {
-                throw new HttpError(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, 500, {
-                    err: err,
-                    campaigns: campaigns,
-                });
-            }
-        }
-        return dynamicDataArray.flat();
-    }
 }

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

@@ -86,7 +86,9 @@ export declare enum swapxCampaigns {
     Swapx_wstkscUSD_scUSD_wstkscUSD_gauge_Swapx = "Swapx wstkscUSD/scUSD wstkscUSD gauge Swapx 0xEd08f5caD599E7F523d6B3FD598005B43aA003bb",
     Swapx_wstkscUSD_scUSD_scUSD_gauge_Swapx = "Swapx wstkscUSD/scUSD scUSD gauge Swapx 0xEd08f5caD599E7F523d6B3FD598005B43aA003bb",
     Swapx_wstkscUSD_bUSDCe20_wstkscUSD_gauge_Swapx = "Swapx wstkscUSD/bUSDC.e-20 wstkscUSD gauge Swapx 0x85279f76f6ce5bb26f721931ba4e3188cd28ad51",
-    Swapx_wstkscUSD_bUSDCe20_bUSDCe20_gauge_Swapx = "Swapx wstkscUSD/bUSDC.e-20 bUSDC.e-20 gauge Swapx 0x85279f76f6ce5bb26f721931ba4e3188cd28ad51"
+    Swapx_wstkscUSD_bUSDCe20_bUSDCe20_gauge_Swapx = "Swapx wstkscUSD/bUSDC.e-20 bUSDC.e-20 gauge Swapx 0x85279f76f6ce5bb26f721931ba4e3188cd28ad51",
+    Swapx_wstkscUSD_aSonUSDC_aSonUSDC_gauge_Swapx = "Swapx wstkscUSD/aSonUSDC aSonUSDC gauge Swapx 0xf248b0EF6d45Aa492C73699B71748b5D1a6770C6",
+    Swapx_wstkscUSD_aSonUSDC_wstkscUSD_gauge_Swapx = "Swapx wstkscUSD/aSonUSDC wstkscUSD gauge Swapx 0xF2a497F783C6bfEe0670757462a31f9429fdE53d"
 }
 export declare enum celoCampaigns {
     UniswapV3_cUSD_USDT_Celo = "UniswapV3 cUSD/USDT Celo 0x5dC631aD6C26BEA1a59fBF2C2680CF3df43d249f",

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

@@ -153,6 +153,8 @@ export var swapxCampaigns;
     swapxCampaigns["Swapx_wstkscUSD_scUSD_scUSD_gauge_Swapx"] = "Swapx wstkscUSD/scUSD scUSD gauge Swapx 0xEd08f5caD599E7F523d6B3FD598005B43aA003bb";
     swapxCampaigns["Swapx_wstkscUSD_bUSDCe20_wstkscUSD_gauge_Swapx"] = "Swapx wstkscUSD/bUSDC.e-20 wstkscUSD gauge Swapx 0x85279f76f6ce5bb26f721931ba4e3188cd28ad51";
     swapxCampaigns["Swapx_wstkscUSD_bUSDCe20_bUSDCe20_gauge_Swapx"] = "Swapx wstkscUSD/bUSDC.e-20 bUSDC.e-20 gauge Swapx 0x85279f76f6ce5bb26f721931ba4e3188cd28ad51";
+    swapxCampaigns["Swapx_wstkscUSD_aSonUSDC_aSonUSDC_gauge_Swapx"] = "Swapx wstkscUSD/aSonUSDC aSonUSDC gauge Swapx 0xf248b0EF6d45Aa492C73699B71748b5D1a6770C6";
+    swapxCampaigns["Swapx_wstkscUSD_aSonUSDC_wstkscUSD_gauge_Swapx"] = "Swapx wstkscUSD/aSonUSDC wstkscUSD gauge Swapx 0xF2a497F783C6bfEe0670757462a31f9429fdE53d";
 })(swapxCampaigns || (swapxCampaigns = {}));
 export var celoCampaigns;
 (function (celoCampaigns) {
@@ -932,6 +934,34 @@ const EtherlinkInterfaceCampaigns = {
     },
 };
 const SwapxInterfaceCampaigns = {
+    [swapxCampaigns.Swapx_wstkscUSD_aSonUSDC_wstkscUSD_gauge_Swapx]: {
+        campaignType: Campaign.CLAMM,
+        computeChainId: ChainId.SONIC,
+        hooks: [],
+        poolAddress: "0x151283BEfA4301619b1Ec2BdAA23A2e49B41D8E7",
+        whitelist: ["0xF2a497F783C6bfEe0670757462a31f9429fdE53d"],
+        blacklist: [],
+        url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
+        forwarders: [],
+        isOutOfRangeIncentivized: false,
+        weightFees: 2000,
+        weightToken0: 4000,
+        weightToken1: 4000,
+    },
+    [swapxCampaigns.Swapx_wstkscUSD_aSonUSDC_aSonUSDC_gauge_Swapx]: {
+        campaignType: Campaign.CLAMM,
+        computeChainId: ChainId.SONIC,
+        hooks: [],
+        poolAddress: "0x151283BEfA4301619b1Ec2BdAA23A2e49B41D8E7",
+        whitelist: ["0xf248b0EF6d45Aa492C73699B71748b5D1a6770C6"],
+        blacklist: [],
+        url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
+        forwarders: [],
+        isOutOfRangeIncentivized: false,
+        weightFees: 2000,
+        weightToken0: 4000,
+        weightToken1: 4000,
+    },
     [swapxCampaigns.Swapx_SWPx_USDCe_Swapx]: {
         campaignType: Campaign.CLAMM,
         computeChainId: ChainId.SONIC,

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

@@ -744,7 +744,7 @@ export declare abstract class RewardService {
         claimed: string;
         proofs: string[];
     })[]>;
-    static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[], connectedChainId?: MerklChainId | null, withTestTokens?: boolean): Promise<{
+    static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[], connectedChainId?: MerklChainId | null, withTestTokens?: boolean, claimableOnly?: boolean): Promise<{
         chain: Chain;
         rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }[]>;
@@ -782,5 +782,8 @@ export declare abstract class RewardService {
         claimed: string;
     }[]>;
     static getUnclaimed(x: CampaignIdWithoutPageModel): Promise<Record<string, string>>;
+    /**
+     * @deprecated
+     */
     static extractDailyRewardsRecordFromDynamicData<C extends CampaignEnum>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): Promise<DailyRewardsRecord["model"]>;
 }

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

@@ -226,7 +226,7 @@ export class RewardService {
         }
         return rewards;
     }
-    static async getUserRewardsByChain(user, withToken, chainFilter = [], connectedChainId = null, withTestTokens = false) {
+    static async getUserRewardsByChain(user, withToken, chainFilter = [], connectedChainId = null, withTestTokens = false, claimableOnly = false) {
         const chains = await ChainService.findMany({});
         let chainIds = !chainFilter || !chainFilter.length
             ? chains.map(({ id }) => id)
@@ -244,7 +244,8 @@ export class RewardService {
             .filter(({ status }) => status === "fulfilled")
             .map(x => x.value);
         /** Load rewards from api DB */
-        const rewards = (await RewardService.getByRecipient(user, merkleRoots.map(({ live }) => live), withToken, withTestTokens)).filter(reward => chainIds.includes(reward.RewardToken.chainId));
+        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()) {
             const chain = chains.find(chain => chain.id === chainId);
@@ -353,6 +354,9 @@ export class RewardService {
             return acc;
         }, {});
     }
+    /**
+     * @deprecated
+     */
     static async extractDailyRewardsRecordFromDynamicData(type, dynamicData, timestamp = BigInt(moment().unix())) {
         const typesWithoutApr = [CampaignEnum.INVALID];
         if (typesWithoutApr.includes(type))
@@ -366,8 +370,6 @@ export class RewardService {
             const dayspan = Math.max(1, Math.floor(timespan / DAY));
             const dailyAmount = isWithinTimespan ? BigInt(amount) / BigInt(dayspan) : BigInt(0);
             const campaignIdInDb = CampaignService.hashId({ campaignId, distributionChain: chainId });
-            const tokenToAmount = new Map();
-            tokenToAmount.set(TokenService.hashId({ address: rewardToken, chainId }), dailyAmount);
             try {
                 let token;
                 try {
@@ -377,7 +379,7 @@ export class RewardService {
                     await TokenService.findManyOrCreate([{ address: rewardToken, chainId }]);
                     token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
                 }
-                const campaignDailyValue = await TokenService.getValueByTokenId(tokenToAmount);
+                const campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardToken, chainId }), dailyAmount);
                 breakdowns.push({
                     campaignId: campaignIdInDb,
                     value: campaignDailyValue,

package/dist/src/modules/v4/router.d.ts

@@ -1197,7 +1197,7 @@ export declare const v4: Elysia<"/v4", false, {
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -1764,7 +1764,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 authorization: string;
                             };
                             response: {
-                                200: unknown[];
+                                200: unknown[] | undefined;
                             };
                         };
                     };
@@ -1782,7 +1782,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 authorization: string;
                             };
                             response: {
-                                200: unknown[];
+                                200: unknown[] | undefined;
                             };
                         };
                     };
@@ -1812,7 +1812,7 @@ export declare const v4: Elysia<"/v4", false, {
                             authorization: string;
                         };
                         response: {
-                            200: unknown[];
+                            200: unknown[] | undefined;
                         };
                     };
                 };
@@ -3324,6 +3324,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 test?: boolean | undefined;
                                 chainIds?: number[] | undefined;
                                 reloadChainId?: number | undefined;
+                                claimableOnly?: boolean | undefined;
                             };
                             headers: unknown;
                             response: {
@@ -3443,6 +3444,7 @@ export declare const v4: Elysia<"/v4", false, {
                         query: {
                             test?: boolean | undefined;
                             reloadChainId?: number | undefined;
+                            claimableOnly?: boolean | undefined;
                             chainId: number[];
                         };
                         headers: unknown;

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

@@ -161,7 +161,7 @@ export declare abstract class TokenService {
         address: string;
         chainId: number;
     }[]): Promise<number>;
-    static getValueByTokenId(tokenAmountMap: Map<string, bigint>): Promise<number>;
+    static getValueByTokenId(id: string, amount: bigint): Promise<number>;
     /**
      * Counts the number of tokens that complies to query
      * @description used for pagination purposes

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

@@ -206,15 +206,9 @@ export class TokenService {
             return sum + value;
         }, 0);
     }
-    static async getValueByTokenId(tokenAmountMap) {
-        const ids = Array.from(tokenAmountMap.keys());
-        const tokens = await TokenService.findMany({ id: ids });
-        if (tokens.length !== ids.length)
-            throw new Error("Cannot find one or more token(s) in the database.");
-        let totalValue = 0;
-        for (const token of tokens)
-            totalValue += (bigIntToNumber(tokenAmountMap.get(token.id) ?? 0n, token.decimals) ?? 0) * (token.price ?? 0);
-        return totalValue;
+    static async getValueByTokenId(id, amount) {
+        const token = await TokenService.findUniqueOrThrow(id);
+        return (bigIntToNumber(amount, token.decimals) ?? 0) * (token.price ?? 0);
     }
     /**
      * Counts the number of tokens that complies to query

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

@@ -2,5 +2,8 @@ import { Campaign, type CampaignDynamicData } from "@sdk";
 import type { TvlRecord } from "./tvl.model";
 export declare abstract class TvlService {
     static hashId(opportunityId: string, timestamp: bigint): string;
+    /**
+     * @deprecated
+     */
     static extractFromDynamicData<C extends Campaign>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): TvlRecord["model"];
 }

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

@@ -5,6 +5,9 @@ export class TvlService {
     static hashId(opportunityId, timestamp) {
         return Bun.hash(`${opportunityId}${timestamp}`).toString();
     }
+    /**
+     * @deprecated
+     */
     static extractFromDynamicData(type, dynamicData, timestamp = BigInt(moment().unix())) {
         const typesWithoutApr = [Campaign.INVALID, Campaign.JSON_AIRDROP, Campaign.ERC20_SNAPSHOT];
         if (typesWithoutApr.includes(type))

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

@@ -112,6 +112,7 @@ export declare const UserController: Elysia<"/users", false, {
                             test?: boolean | undefined;
                             chainIds?: number[] | undefined;
                             reloadChainId?: number | undefined;
+                            claimableOnly?: boolean | undefined;
                         };
                         headers: unknown;
                         response: {
@@ -231,6 +232,7 @@ export declare const UserController: Elysia<"/users", false, {
                     query: {
                         test?: boolean | undefined;
                         reloadChainId?: number | undefined;
+                        claimableOnly?: boolean | undefined;
                         chainId: number[];
                     };
                     headers: unknown;

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

@@ -25,7 +25,7 @@ export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["U
 })
     // ─── Get User's Rewards With Breakdown And Details for our FE ────────
     .get("/:address/rewards/breakdowns", async ({ params, query }) => {
-    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, true, query?.chainIds, query.reloadChainId ?? null, !!query.test ? query.test : false);
+    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, true, query?.chainIds, query.reloadChainId ?? null, !!query.test ? query.test : false, !!query.claimableOnly);
     return RewardService.splitRewardsBreakdownByOpportunity(rewardsByChain);
 }, {
     params: UserUniqueDto,
@@ -42,7 +42,7 @@ export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["U
 })
     // ─── Get User's Rewards With Breakdown ──────────────────────────────
     .get("/:address/rewards", async ({ params, query }) => {
-    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, false, typeof query.chainId === "number" ? [query.chainId] : query.chainId, !!query.reloadChainId ? query.reloadChainId : null, !!query.test ? query.test : false);
+    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, false, typeof query.chainId === "number" ? [query.chainId] : query.chainId, !!query.reloadChainId ? query.reloadChainId : null, !!query.test ? query.test : false, !!query.claimableOnly);
     return RewardService.removeOpportunityFromRewardBreakdown(rewardsByChain);
 }, {
     params: UserUniqueDto,

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

@@ -10,6 +10,7 @@ export declare const UserRewardRouteDto: import("@sinclair/typebox").TObject<{
     chainId: import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>, number[]>;
     reloadChainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     test: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    claimableOnly: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
 }>;
 export declare const UserRewardsResourceDto: import("@sinclair/typebox").TObject<{
     chain: import("@sinclair/typebox").TObject<{
@@ -46,6 +47,7 @@ export declare const OptionalChainIdDto: import("@sinclair/typebox").TObject<{
     chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>, number[]>>;
     reloadChainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     test: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    claimableOnly: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
 }>;
 export declare const UserDto: import("@sinclair/typebox").TObject<{
     address: import("@sinclair/typebox").TString;

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

@@ -10,6 +10,7 @@ export const UserRewardRouteDto = t.Object({
         description: "An optional chainId to bypass the cache and check if there was very recently a claim on this chain",
     })),
     test: t.Optional(t.Boolean({ description: "Include test token rewards" })),
+    claimableOnly: t.Optional(t.Boolean({ description: "Include only claimable rewards (to avoid transferring zero amounts)" })),
 }, {
     description: "A required comma separated list of chain ids.<br>You can get the list of all supported chains by calling [GET /v4/chains](#tag/chains/GET/v4/chains/)",
 });
@@ -47,6 +48,7 @@ export const OptionalChainIdDto = t.Object({
         .Encode(value => [...value])),
     reloadChainId: t.Optional(t.Numeric()),
     test: t.Optional(t.Boolean({ description: "Include test token rewards" })),
+    claimableOnly: t.Optional(t.Boolean({ description: "Include only claimable rewards (to avoid transferring zero amounts)" })),
 });
 export const UserDto = t.Object({
     address: t.String(),