@merkl/api 0.10.297 → 0.10.299

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

@@ -2,7 +2,7 @@ import { BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
-import { CampaignIdDto, CampaignIdWithoutPageDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, UpdatePendingDto, } from "./reward.model";
+import { CampaignIdDto, CampaignIdWithoutPageDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, TokenIdDto, UpdatePendingDto, } from "./reward.model";
 import { RewardService } from "./reward.service";
 // ─── Rewards Controller ──────────────────────────────────────────────────────
 export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags: ["Rewards"] } })
@@ -17,12 +17,49 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
     },
 })
     // ─── Get Total Amount Rewarded For Campaign Id ──────────────────────
-    .get("/total", async ({ query }) => await RewardService.total(query), {
+    .get("/total", async ({ query }) => await RewardService.totalForCampaign(query), {
     query: CampaignIdDto,
     beforeHandle: ({ query }) => {
         throwOnUnsupportedChainId(query.chainId);
     },
     detail: { description: "Returns the total amount distributed for a given campaign" },
+})
+    // ─── Get Reward Count By Chain And Root For Campaign Id ─────────────
+    .get("/count", async ({ query }) => await RewardService.countForCampaign(query), {
+    query: CampaignIdDto,
+    beforeHandle: ({ query }) => {
+        throwOnUnsupportedChainId(query.chainId);
+    },
+    detail: { hide: true },
+})
+    // ─── Get Reward Breakdowns For Token ───────────────────────────────
+    .get("/token", async ({ query }) => await RewardService.breakdownForToken(query), {
+    query: TokenIdDto,
+    beforeHandle: ({ query }) => {
+        query.address = throwOnInvalidRequiredAddress(query.address);
+        throwOnUnsupportedChainId(query.chainId);
+    },
+    detail: {
+        description: "Returns the all the address that received rewards for a given token, sorted by descending amounts",
+    },
+})
+    // ─── Get Total Amount Rewarded For Token ───────────────────────────
+    .get("/token/total", async ({ query }) => await RewardService.totalForToken(query), {
+    query: TokenIdDto,
+    beforeHandle: ({ query }) => {
+        query.address = throwOnInvalidRequiredAddress(query.address);
+        throwOnUnsupportedChainId(query.chainId);
+    },
+    detail: { description: "Returns the total amount distributed for a given token" },
+})
+    // ─── Get Reward Count By Chain And Root For Token ───────────────────
+    .get("/token/count", async ({ query }) => await RewardService.countForToken(query), {
+    query: TokenIdDto,
+    beforeHandle: ({ query }) => {
+        query.address = throwOnInvalidRequiredAddress(query.address);
+        throwOnUnsupportedChainId(query.chainId);
+    },
+    detail: { hide: true },
 })
     // ─── Create Many Rewards ─────────────────────────────────────────────
     .post("/engine", async ({ body }) => await RewardService.createManyReward(body), {
@@ -58,14 +95,6 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
     body: UpdatePendingDto,
     beforeHandle: EngineGuard,
     detail: { hide: true },
-})
-    // ─── Get Reward Count By Chain And Root ──────────────────────────────
-    .get("/count", async ({ query }) => await RewardService.count(query), {
-    query: CampaignIdDto,
-    beforeHandle: ({ query }) => {
-        throwOnUnsupportedChainId(query.chainId);
-    },
-    detail: { hide: true },
 })
     // ─── Get Reward Count By Chain And Root ──────────────────────────────
     .get("/count/chains", async () => await RewardService.countAllchains(), {

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

@@ -167,6 +167,12 @@ export declare const CampaignIdDto: import("@sinclair/typebox").TObject<{
     page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
+export declare const TokenIdDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    address: import("@sinclair/typebox").TString;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
 export declare const UserRewardV3Dto: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
     symbol: import("@sinclair/typebox").TString;
     decimals: import("@sinclair/typebox").TNumber;
@@ -214,6 +220,7 @@ export type CampaignIdWithoutPageModel = {
 };
 export type CampaignIdListModel = typeof CampaignIdListDto.static;
 export type CampaignIdModel = typeof CampaignIdDto.static;
+export type TokenIdModel = typeof TokenIdDto.static;
 export type UserRewardV3Model = typeof UserRewardV3Dto.static;
 export type RewardV3Model = typeof RewardV3Dto.static;
 export type BreakdownForCampaignsRaw = {

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

@@ -112,6 +112,16 @@ export const CampaignIdDto = t.Object({
     page: t.Optional(t.Numeric({ description: "Page number", default: 0 })), // 0-indexed
     items: t.Optional(t.Numeric({ description: "Number of returned rows", default: 20 })), // items per page
 });
+export const TokenIdDto = t.Object({
+    chainId: t.Numeric({
+        description: "Chain ID",
+    }),
+    address: t.String({
+        description: "Token Address",
+    }),
+    page: t.Optional(t.Numeric({ description: "Page number", default: 0 })), // 0-indexed
+    items: t.Optional(t.Numeric({ description: "Number of returned rows", default: 20 })), // items per page
+});
 export const UserRewardV3Dto = t.Record(t.String({ title: "TokenAddress" }), t.Object({
     symbol: t.String(),
     decimals: t.Number(),

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

@@ -1,6 +1,6 @@
 import type { Prisma } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
-import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity } from "./reward.model";
+import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity, TokenIdModel } from "./reward.model";
 export declare abstract class RewardRepository {
     static createManyReward(rewards: CreateManyRewardModel): Promise<Prisma.BatchPayload>;
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<Prisma.BatchPayload>;
@@ -170,16 +170,24 @@ export declare abstract class RewardRepository {
     }[]>;
     static findManyRootsWithRewardOnChain(chainId: number): Promise<string[]>;
     static breakdownForCampaign(root: string, id: string, query: CampaignIdModel): Promise<BreakdownForCampaignsRaw[]>;
-    static total(campaignId: string, root: string): Promise<{
+    static totalForCampaign(campaignId: string, root: string): Promise<{
         campaignId: string;
         amount: bigint;
     }>;
+    static countForCampaign(campaignId: string, root: string): Promise<{
+        count: number;
+    }>;
+    static breakdownForToken(root: string, id: string, query: TokenIdModel): Promise<BreakdownForCampaignsRaw[]>;
+    static totalForToken(tokenId: string, root: string): Promise<{
+        tokenId: string;
+        amount: bigint;
+    }>;
+    static countForToken(tokenId: string, root: string): Promise<{
+        count: number;
+    }>;
     static getAmountAndClaimedForCampaigns(root: string, x: CampaignIdWithoutPageModel): Promise<{
         campaignId: string;
         amount: string;
         claimed: string;
     }[]>;
-    static count(campaignId: string, root: string): Promise<{
-        count: number;
-    }>;
 }

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

@@ -284,7 +284,7 @@ export class RewardRepository {
     `, root, id, items, items * page);
         return result;
     }
-    static async total(campaignId, root) {
+    static async totalForCampaign(campaignId, root) {
         const totalAmount = await apiDbClient.rewardBreakdown.findMany({
             where: {
                 campaignId,
@@ -304,32 +304,88 @@ export class RewardRepository {
         }, { campaignId, amount: 0n });
         return reducedData;
     }
-    static async getAmountAndClaimedForCampaigns(root, x) {
-        return await apiDbClient.rewardBreakdown.findMany({
+    static async countForCampaign(campaignId, root) {
+        const count = await apiDbClient.rewardBreakdown.count({
+            where: {
+                campaignId,
+                Reward: {
+                    root,
+                },
+            },
+        });
+        return { count };
+    }
+    static async breakdownForToken(root, id, query) {
+        const { page: _page, items: _items } = query;
+        const page = _page || 0;
+        const items = _items || 50;
+        const result = await apiDbClient.$queryRawUnsafe(`
+      SELECT 
+        r."recipient",
+        SUM(rb."amount"::numeric)::text AS amount,
+        SUM(rb."claimed"::numeric)::text AS claimed,
+        SUM(rb."pending"::numeric)::text AS pending
+      FROM 
+        "RewardBreakdown" rb
+      INNER JOIN 
+        "Reward" r ON rb."rewardId" = r."id"
+      WHERE 
+        r."root" = $1 AND r."rewardTokenId" = $2
+      GROUP BY 
+        r."recipient"
+      ORDER BY 
+        (SUM(rb."amount"::numeric) + SUM(rb."pending"::numeric)) DESC
+      LIMIT $3
+      OFFSET $4
+    `, root, id, items, items * page);
+        return result;
+    }
+    static async totalForToken(tokenId, root) {
+        const totalAmount = await apiDbClient.rewardBreakdown.findMany({
+            where: {
+                Reward: {
+                    rewardTokenId: tokenId,
+                    root,
+                },
+            },
             select: {
-                claimed: true,
                 amount: true,
+                pending: true,
                 campaignId: true,
             },
+        });
+        const reducedData = totalAmount.reduce((acc, { amount, pending }) => {
+            acc.amount += BigInt(amount) + BigInt(pending ?? 0);
+            return acc;
+        }, { tokenId, amount: 0n });
+        return reducedData;
+    }
+    static async countForToken(tokenId, root) {
+        const count = await apiDbClient.rewardBreakdown.count({
             where: {
-                campaignId: {
-                    in: x.campaignIds.map(campaignId => CampaignService.hashId({ distributionChain: x.chainId, campaignId })),
-                },
                 Reward: {
+                    rewardTokenId: tokenId,
                     root,
                 },
             },
         });
+        return { count };
     }
-    static async count(campaignId, root) {
-        const count = await apiDbClient.rewardBreakdown.count({
+    static async getAmountAndClaimedForCampaigns(root, x) {
+        return await apiDbClient.rewardBreakdown.findMany({
+            select: {
+                claimed: true,
+                amount: true,
+                campaignId: true,
+            },
             where: {
-                campaignId,
+                campaignId: {
+                    in: x.campaignIds.map(campaignId => CampaignService.hashId({ distributionChain: x.chainId, campaignId })),
+                },
                 Reward: {
                     root,
                 },
             },
         });
-        return { count };
     }
 }

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

@@ -2,7 +2,7 @@ import type { CacheKeys } from "../../../cache/keys";
 import type { Chain } from "../../../../database/api/.generated";
 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 type { CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, DailyRewardsRecord, RegisterClaimsModel, RewardBreakdown, TokenIdModel, UpdatePendingModel } from "./reward.model";
 import { RewardRepository } from "./reward.repository";
 export declare abstract class RewardService {
     static hashId(root: string, recipient: string, rewardTokenId: string): string;
@@ -557,13 +557,21 @@ export declare abstract class RewardService {
         rewards: Record<string, number>;
     }>>;
     static breakdownForCampaign(query: CampaignIdModel): Promise<import("./reward.model").BreakdownForCampaignsRaw[]>;
-    static count(query: CampaignIdModel): Promise<{
+    static countForCampaign(query: CampaignIdModel): Promise<{
         count: number;
     }>;
-    static total(query: CampaignIdModel): Promise<{
+    static totalForCampaign(query: CampaignIdModel): Promise<{
         campaignId: string;
         amount: bigint;
     }>;
+    static breakdownForToken(query: TokenIdModel): Promise<import("./reward.model").BreakdownForCampaignsRaw[]>;
+    static countForToken(query: TokenIdModel): Promise<{
+        count: number;
+    }>;
+    static totalForToken(query: TokenIdModel): Promise<{
+        tokenId: string;
+        amount: bigint;
+    }>;
     static getAmountAndClaimedForCampaigns(x: CampaignIdWithoutPageModel): Promise<{
         campaignId: string;
         amount: string;

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

@@ -285,14 +285,29 @@ export class RewardService {
         const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
         return RewardRepository.breakdownForCampaign(root.live, id, query);
     }
-    static async count(query) {
+    static async countForCampaign(query) {
         const root = await MerklRootService.fetch(query.chainId);
         const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
-        return RewardRepository.count(id, root.live);
+        return RewardRepository.countForCampaign(id, root.live);
     }
-    static async total(query) {
+    static async totalForCampaign(query) {
         const root = await MerklRootService.fetch(query.chainId);
-        return RewardRepository.total(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
+        return RewardRepository.totalForCampaign(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
+    }
+    static async breakdownForToken(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
+        return RewardRepository.breakdownForToken(root.live, id, query);
+    }
+    static async countForToken(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
+        return RewardRepository.countForToken(id, root.live);
+    }
+    static async totalForToken(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
+        return RewardRepository.totalForToken(id, root.live);
     }
     static async getAmountAndClaimedForCampaigns(x) {
         const currentRoot = await MerklRootService.fetch(x.chainId);

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

@@ -1169,6 +1169,85 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
+        } & {
+            count: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                        chainId: number;
+                        campaignId: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            count: number;
+                        };
+                    };
+                };
+            };
+        } & {
+            token: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        items?: number | undefined;
+                        page?: number | undefined;
+                        chainId: number;
+                        address: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: import("./reward").BreakdownForCampaignsRaw[];
+                    };
+                };
+            };
+        } & {
+            token: {
+                total: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            items?: number | undefined;
+                            page?: number | undefined;
+                            chainId: number;
+                            address: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                tokenId: string;
+                                amount: bigint;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            token: {
+                count: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            items?: number | undefined;
+                            page?: number | undefined;
+                            chainId: number;
+                            address: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                count: number;
+                            };
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 post: {
@@ -1276,25 +1355,6 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
-        } & {
-            count: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: {
-                        items?: number | undefined;
-                        page?: number | undefined;
-                        chainId: number;
-                        campaignId: string;
-                    };
-                    headers: unknown;
-                    response: {
-                        200: {
-                            count: number;
-                        };
-                    };
-                };
-            };
         } & {
             count: {
                 chains: {
@@ -2652,9 +2712,7 @@ export declare const v4: Elysia<"/v4", false, {
                     }[];
                     params: {};
                     query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
+                    headers: unknown;
                     response: {
                         200: {
                             address: string;

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

@@ -72,9 +72,6 @@ export class StatusRepository {
         return await apiDbClient.campaignStatus.update({
             where: {
                 campaignId: CampaignService.hashId(campaignUnique),
-                status: {
-                    not: "PROCESSING", // To throw an error if the status is already PROCESSING
-                },
             },
             data: {
                 status: "PROCESSING",

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

@@ -19,8 +19,8 @@ export class StatusService {
     }
     static async update(campaignUnique, status) {
         // Check if the status exists already, otherwise create it
-        const campaignExists = await StatusRepository.findUnique(campaignUnique);
-        if (!campaignExists) {
+        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
+        if (!campaignStatus) {
             let campaign = await CampaignService.findUnique(campaignUnique);
             if (!campaign) {
                 await CampaignService.fill([campaignUnique]);