@merkl/api 0.10.186 → 0.10.188

package/dist/src/eden/index.d.ts

@@ -1282,12 +1282,14 @@ declare const eden: {
                 } | null;
             }>>;
             rewards: {
-                full: {
-                    get: (options?: {
+                breakdowns: {
+                    get: (options: {
                         headers?: Record<string, unknown> | undefined;
-                        query?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId?: number | undefined;
+                        };
                         fetch?: RequestInit | undefined;
-                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                         200: (Omit<{
                             chain: import("../../database/api/.generated").Chain;
                             rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["format"]>>;
@@ -3606,13 +3608,15 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{
@@ -5716,12 +5720,14 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 } | null;
             }>>;
             rewards: {
-                full: {
-                    get: (options?: {
+                breakdowns: {
+                    get: (options: {
                         headers?: Record<string, unknown> | undefined;
-                        query?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId?: number | undefined;
+                        };
                         fetch?: RequestInit | undefined;
-                    } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                         200: (Omit<{
                             chain: import("../../database/api/.generated").Chain;
                             rewards: Awaited<ReturnType<typeof import("../modules/v4/reward").RewardService["format"]>>;

package/dist/src/index.d.ts

@@ -1631,13 +1631,15 @@ declare const app: Elysia<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

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

@@ -1,6 +1,6 @@
 import type { CacheKeys } from "../../../cache/keys";
 import type { Chain } from "../../../../database/api/.generated";
-import { Campaign, type CampaignDynamicData, type ChainId } from "@sdk";
+import { Campaign, type CampaignDynamicData, type ChainId, type MerklChainId } from "@sdk";
 import { type LightOpportunityFromDB, type Opportunity } from "../opportunity";
 import type { CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, DailyRewardsRecord, RegisterClaimsModel, RewardBreakdown, UpdatePendingModel } from "./reward.model";
 import { RewardRepository } from "./reward.repository";
@@ -537,7 +537,7 @@ export declare abstract class RewardService {
         root: string;
         proofs: string[];
     })[]>;
-    static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[]): Promise<{
+    static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[], connectedChainId?: MerklChainId | null): Promise<{
         chain: Chain;
         rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }[]>;

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

@@ -1,5 +1,5 @@
 import { log } from "../../../utils/logger";
-import { Campaign, DistributorService, NETWORK_LABELS } from "@sdk";
+import { Campaign, DistributorService, NETWORK_LABELS, } from "@sdk";
 import moment from "moment";
 import { BlacklistService } from "../blacklist";
 import { CacheService } from "../cache";
@@ -150,7 +150,10 @@ export class RewardService {
             // -> claim is on the current root (chainData.merklRoot) -> claimed === accumulated
             if (merklRootClaimedOn === roots.live) {
                 for (const breakdown of reward.Breakdown) {
+                    if (BigInt(breakdown.claimed) === BigInt(breakdown.amount))
+                        continue;
                     breakdown.claimed = breakdown.amount; // Set unclaim to 0
+                    await RewardRepository.updateClaimed(user, TokenService.hashId(reward.RewardToken), reward.Breakdown[0].campaignId, reward.Breakdown[0].reason, reward.Breakdown[0].amount);
                 }
             }
             // -> claim is on a tree we have in db -> claimed === accumulated of the rewards of lastTree
@@ -169,7 +172,7 @@ export class RewardService {
         }
         return rewards;
     }
-    static async getUserRewardsByChain(user, withToken, chainFilter = []) {
+    static async getUserRewardsByChain(user, withToken, chainFilter = [], connectedChainId = null) {
         const chains = await ChainService.findMany();
         let chainIds = chains.map(({ id }) => id).filter(id => !chainFilter.length || chainFilter.includes(id));
         /** Check if the user is blacklisted */
@@ -193,8 +196,13 @@ export class RewardService {
                 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) })));
+            if ((!connectedChainId || chain.id === connectedChainId) && chainRewards.length > 0) {
+                promises.push(RewardService.checkLastClaim(chainId, user, merkleRoots[index], chainRewards).then(r => {
+                    return { chain, rewards: r };
+                }));
+            }
+            else {
+                promises.push(Promise.resolve({ chain, rewards: chainRewards }));
             }
         }
         const settledPromises = await Promise.allSettled(promises);
@@ -202,6 +210,9 @@ export class RewardService {
             if (promise.status === "rejected") {
                 log.error("checkLastClaim failed", promise.reason);
             }
+            else {
+                res.push({ chain: promise.value.chain, rewards: RewardService.format(promise.value.rewards) });
+            }
         }
         return res;
     }

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

@@ -1613,13 +1613,15 @@ export declare const v4: Elysia<"/v4", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

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

@@ -76,13 +76,15 @@ export declare const UserController: Elysia<"/users", false, {
     users: {
         ":address": {
             rewards: {
-                full: {
+                breakdowns: {
                     get: {
                         body: unknown;
                         params: {
                             address: string;
                         };
-                        query: unknown;
+                        query: {
+                            chainId?: number | undefined;
+                        };
                         headers: unknown;
                         response: {
                             200: (Omit<{

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

@@ -3,7 +3,7 @@ import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../
 import { Elysia } from "elysia";
 import { ChainArrayDto } from "../chain";
 import { RewardService } from "../reward";
-import { GetManyUserQuery, UpdateUserTagsDto, UserDto, UserUniqueDto } from "./user.model";
+import { GetManyUserQuery, OptionalChainIdDto, UpdateUserTagsDto, UserDto, UserUniqueDto } from "./user.model";
 import { UserService } from "./user.service";
 // ─── Users Controller ────────────────────────────────────────────────────────
 export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["Users"] } })
@@ -20,15 +20,16 @@ export const UserController = new Elysia({ prefix: "/users", detail: { tags: ["U
     return await UserService.findUnique(params.address);
 })
     // ─── Get User's Rewards With Breakdown And Details for our FE ────────
-    .get(
-// TODO: redefine as /:address/rewards/breakdowns to follow REST standard (URI components should be nouns)
-"/:address/rewards/full", async ({ params }) => {
-    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, true);
+    .get("/:address/rewards/breakdowns", async ({ params, query }) => {
+    const rewardsByChain = await RewardService.getUserRewardsByChain(params.address, true, [], query.chainId ?? null);
     return RewardService.splitRewardsBreakdownByOpportunity(rewardsByChain);
 }, {
     params: UserUniqueDto,
-    beforeHandle: ({ params }) => {
+    query: OptionalChainIdDto,
+    beforeHandle: ({ params, query }) => {
         params.address = throwOnInvalidRequiredAddress(params.address);
+        if (!!query.chainId)
+            throwOnUnsupportedChainId(query.chainId);
     },
     detail: { hide: true },
 })

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

@@ -8,6 +8,9 @@ export type User = Resource<"User">;
 export declare const UserUniqueDto: import("@sinclair/typebox").TObject<{
     address: import("@sinclair/typebox").TString;
 }>;
+export declare const OptionalChainIdDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
 export declare const UserDto: import("@sinclair/typebox").TObject<{
     address: import("@sinclair/typebox").TString;
     tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
@@ -23,4 +26,5 @@ export declare const UpdateUserTagsDto: import("@sinclair/typebox").TObject<{
 }>;
 export type UserUniqueModel = typeof UserUniqueDto.static;
 export type UserModel = typeof UserDto.static;
+export type OptionalChainIdModel = typeof OptionalChainIdDto.static;
 export type GetManyUserModel = typeof GetManyUserQuery.static;

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

@@ -3,6 +3,9 @@ import { t } from "elysia";
 export const UserUniqueDto = t.Object({
     address: t.String(),
 });
+export const OptionalChainIdDto = t.Object({
+    chainId: t.Optional(t.Numeric()),
+});
 export const UserDto = t.Object({
     address: t.String(),
     tags: t.Array(t.String()),

package/dist/src/routes/v3/blacklist.d.ts

@@ -1637,13 +1637,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/campaigns.d.ts

@@ -1640,13 +1640,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/campaignsInfo.d.ts

@@ -1631,13 +1631,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/multiChainPositions.d.ts

@@ -1636,13 +1636,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/opportunity.d.ts

@@ -1654,13 +1654,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/positions.d.ts

@@ -1655,13 +1655,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/rewards.d.ts

@@ -1637,13 +1637,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/updates.d.ts

@@ -1638,13 +1638,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{

package/dist/src/routes/v3/userRewards.d.ts

@@ -1640,13 +1640,15 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
         users: {
             ":address": {
                 rewards: {
-                    full: {
+                    breakdowns: {
                         get: {
                             body: unknown;
                             params: {
                                 address: string;
                             };
-                            query: unknown;
+                            query: {
+                                chainId?: number | undefined;
+                            };
                             headers: unknown;
                             response: {
                                 200: (Omit<{