@merkl/api 0.10.296 → 0.10.298

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>;
@@ -132,6 +132,18 @@ export declare abstract class RewardRepository {
             recipient: string;
         };
     }[]>;
+    static upsertPendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
+        reason: string;
+        pending: string;
+        id: number;
+        campaignId: string;
+        amount: string;
+        protocolId: string | null;
+        claimed: string;
+        auxiliaryData1: string | null;
+        auxiliaryData2: string | null;
+        rewardId: string;
+    }[]>;
     static updatePendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
         reason: string;
         pending: string;
@@ -158,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

@@ -158,6 +158,46 @@ export class RewardRepository {
             },
         });
     }
+    static async upsertPendings(rewardTokenId, root, campaignId, toUpdate) {
+        const users = toUpdate.map(x => x.recipient);
+        await UserService.createMany(users.map(x => ({ address: x, tags: [] })));
+        return await apiDbClient.$transaction(toUpdate.map(x => {
+            const rewardId = RewardService.hashId(root, x.recipient, rewardTokenId);
+            return apiDbClient.rewardBreakdown.upsert({
+                where: {
+                    rewardId_campaignId_reason: {
+                        rewardId: RewardService.hashId(root, x.recipient, rewardTokenId),
+                        campaignId: campaignId,
+                        reason: x.reason,
+                    },
+                },
+                update: {
+                    pending: x.pending,
+                    auxiliaryData1: x.auxiliaryData1,
+                    auxiliaryData2: x.auxiliaryData2,
+                },
+                create: {
+                    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 updatePendings(rewardTokenId, root, campaignId, toUpdate) {
         return await apiDbClient.$transaction(toUpdate.map(x => {
             return apiDbClient.rewardBreakdown.update({
@@ -170,7 +210,6 @@ export class RewardRepository {
                 },
                 data: {
                     pending: x.pending,
-                    reason: x.reason,
                     auxiliaryData1: x.auxiliaryData1,
                     auxiliaryData2: x.auxiliaryData2,
                 },
@@ -245,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,
@@ -265,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

@@ -238,20 +238,23 @@ export class RewardService {
             distributionChain: data.distributionChainId,
             campaignId: data.campaignId,
         });
-        const ids = (await RewardRepository.findManyBreakdownUniques(rewardTokenId, data.root, campaignId)).map(({ Reward, reason }) => Bun.hash(`${Reward.recipient}${reason}`).toString());
-        const toUpdate = [];
-        const toCreate = [];
-        for (const point of data.data) {
-            if (ids.includes(Bun.hash(`${point.recipient}${point.reason}`).toString())) {
-                toUpdate.push(point);
-            }
-            else {
-                toCreate.push(point);
-            }
-        }
-        await RewardRepository.updatePendings(rewardTokenId, data.root, campaignId, toUpdate);
-        await RewardRepository.createPendings(rewardTokenId, data.root, campaignId, toCreate);
-        return { created: toCreate.length, updated: toUpdate.length };
+        // const ids = (await RewardRepository.findManyBreakdownUniques(rewardTokenId, data.root, campaignId)).map(
+        //   ({ Reward, reason }) => Bun.hash(`${Reward.recipient}${reason}`).toString()
+        // );
+        // const toUpdate = [];
+        // const toCreate = [];
+        // for (const point of data.data) {
+        //   if (ids.includes(Bun.hash(`${point.recipient}${point.reason}`).toString())) {
+        //     toUpdate.push(point);
+        //   } else {
+        //     toCreate.push(point);
+        //   }
+        // }
+        // await RewardRepository.updatePendings(rewardTokenId, data.root, campaignId, toUpdate);
+        // await RewardRepository.createPendings(rewardTokenId, data.root, campaignId, toCreate);
+        // return { created: toCreate.length, updated: toUpdate.length };
+        await RewardRepository.upsertPendings(rewardTokenId, data.root, campaignId, data.data);
+        return { created: data.data.length, updated: 0 };
     }
     static async countAllchains() {
         const rewardPerRewardTokenId = await RewardRepository.countRewardPerRewardTokenIdAndRoot();
@@ -282,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 totalForCampaign(query) {
+        const root = await MerklRootService.fetch(query.chainId);
+        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 total(query) {
+    static async totalForToken(query) {
         const root = await MerklRootService.fetch(query.chainId);
-        return RewardRepository.total(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
+        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: {

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]);